#include "pch.h"

VOID
P5WorkItemFreePort( PDEVICE_OBJECT Fdo, PFDO_EXTENSION Fdx ) {
    PIO_WORKITEM workItem;

    UNREFERENCED_PARAMETER( Fdo );

    workItem = InterlockedExchangePointer( &Fdx->FreePortWorkItem, NULL );
    if( workItem ) {
        IoFreeWorkItem( workItem );
    }
    
    PptFreePort( Fdx );
}

BOOLEAN
P5SelectDaisyChainDevice(
    IN  PUCHAR  Controller,
    IN  UCHAR   DeviceId
    )
{
    const ULONG  maxRetries = 4;
    ULONG        retryCount = 0;
    BOOLEAN      selected   = FALSE;
    DD(NULL,DDE,"P5SelectDaisyChainDevice %x %d\n",Controller,DeviceId);
    while( !selected && retryCount < maxRetries ) {
        selected = PptSend1284_3Command( Controller, (UCHAR)(CPP_SELECT | DeviceId) );
        ++retryCount;
    }
    return selected;
}

BOOLEAN
P5DeselectAllDaisyChainDevices(
    IN  PUCHAR  Controller
    )
{
    const ULONG  maxRetries = 4;
    ULONG        retryCount = 0;
    BOOLEAN      deselected = FALSE;
    DD(NULL,DDE,"P5DeselectAllDaisyChainDevices %x\n",Controller);
    while( !deselected && retryCount < maxRetries ) {
        deselected = PptSend1284_3Command( Controller, (UCHAR)CPP_DESELECT );
        ++retryCount;
    }
    return deselected;
}

VOID
P5DeletePdoSymLink(
    IN  PDEVICE_OBJECT  Pdo
    )
//
// clean up symbolic link so we can reuse it immediately for a new PDO
//
{
    PPDO_EXTENSION  pdx = Pdo->DeviceExtension;

    if( pdx->SymLinkName ) {
        UNICODE_STRING  uniSymLinkName;
        NTSTATUS        status;

        DD((PCE)pdx,DDE,"P5DeletePdoSymLink\n");

        RtlInitUnicodeString( &uniSymLinkName, pdx->SymLinkName );
        status = IoDeleteSymbolicLink( &uniSymLinkName );
        PptAssert( STATUS_SUCCESS == status );
        ExFreePool( pdx->SymLinkName );
        pdx->SymLinkName = NULL;
    }

    return;
}

VOID
P5MarkPdoAsHardwareGone(
    IN  PDEVICE_OBJECT  Fdo,
    IN  enum _PdoType   PdoType,
    IN  ULONG           DaisyChainId  OPTIONAL // ignored if PdoType != PdoTypeDaisyChain
    )
{
    PFDO_EXTENSION  fdx = Fdo->DeviceExtension;
    PPDO_EXTENSION  pdx;
    PDEVICE_OBJECT  pdo;

    switch( PdoType ) {

    case PdoTypeRawPort:

        DD((PCE)fdx,DDE,"P5MarkPdoAsHardwareGone - PdoTypeRawPort\n");
        pdo = fdx->RawPortPdo;
        fdx->RawPortPdo = NULL;
        break;

    case PdoTypeEndOfChain:

        DD((PCE)fdx,DDE,"P5MarkPdoAsHardwareGone - PdoTypeEndOfChain\n");
        pdo = fdx->EndOfChainPdo;
        fdx->EndOfChainPdo = NULL;
        break;

    case PdoTypeDaisyChain:

        PptAssert( (0 == DaisyChainId) || (1 == DaisyChainId) );
        DD((PCE)fdx,DDE,"P5MarkPdoAsHardwareGone - PdoTypeDaisyChain - %d\n",DaisyChainId);
        pdo = fdx->DaisyChainPdo[ DaisyChainId ];
        fdx->DaisyChainPdo[ DaisyChainId ] = NULL;
        break;

    case PdoTypeLegacyZip:

        DD((PCE)fdx,DDE,"P5MarkPdoAsHardwareGone - PdoTypeLegacyZip\n");
        pdo = fdx->LegacyZipPdo;
        fdx->LegacyZipPdo = NULL;
        break;

    default:

        DD((PCE)fdx,DDE,"P5MarkPdoAsHardwareGone - Invalid PdoType parameter\n",FALSE);
        PptAssertMsg("P5MarkPdoAsHardwareGone - Invalid PdoType parameter",FALSE);
        return;

    }

    pdx = pdo->DeviceExtension;
    P5DeletePdoSymLink( pdo );
    InsertTailList( &fdx->DevDeletionListHead, &pdx->DevDeletionList );
    pdx->DeleteOnRemoveOk = TRUE;

    return;
}

BOOLEAN
P5IsDeviceStillThere( 
    IN  PDEVICE_OBJECT  Fdo,
    IN  PDEVICE_OBJECT  Pdo
    )
//
// Is the Pdo device still connected to the port represented by the Fdo?
//
// N.B. Fdo must own (have locked for exclusive access) the port before calling this function
//   or we can corrupt the data stream and hang devices connected to the port
//
{
    PFDO_EXTENSION  fdx              = Fdo->DeviceExtension;
    PPDO_EXTENSION  pdx              = Pdo->DeviceExtension;
    BOOLEAN         deviceStillThere = FALSE;
    PCHAR           devIdString      = NULL;
    PUCHAR          controller       = fdx->PortInfo.Controller;
        
    PptAssert( DevTypeFdo == fdx->DevType );
    PptAssert( DevTypePdo == pdx->DevType );

    //
    // Select device if needed, pull a fresh 1284 device ID string
    // from the device, and compare the Mfg and Mdl from the fresh
    // device ID with those stored in our extension. If the Mfg and
    // Mdl fields match then the device is still there.
    //

    switch( pdx->PdoType ) {

    case PdoTypeRawPort:
        
        // raw port is always present - it's a virtual device
        DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeRawPort - StillThere\n");
        deviceStillThere = TRUE;
        break;
        
    case PdoTypeLegacyZip:
        
        deviceStillThere = P5LegacyZipDetected( fdx->PortInfo.Controller );
        if( deviceStillThere ) {
            DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeLegacyZip - StillThere\n");
        } else {
            DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeLegacyZip - Gone\n");
        }
        break;
    
    case PdoTypeDaisyChain:
            
        //
        // Select device, pull a fresh 1284 device ID string
        // from the device, and compare the Mfg and Mdl from the fresh
        // device ID with those stored in our extension. If the Mfg and
        // Mdl fields match then the device is still there.
        //

        {
            UCHAR daisyChainId = pdx->Ieee1284_3DeviceId;

            // select device
            if( P5SelectDaisyChainDevice( controller, daisyChainId ) ) {

                BOOLEAN         bBuildStlDeviceId = FALSE;
                PPDO_EXTENSION  dummyPdx          = NULL;

                devIdString = NULL;

                // do a check to see if this is an SCM Micro device
                dummyPdx = ExAllocatePool( PagedPool, sizeof(PDO_EXTENSION) );
                if( dummyPdx != NULL ) {
                    RtlZeroMemory( dummyPdx, sizeof(PDO_EXTENSION) );
                    dummyPdx->Controller = fdx->PortInfo.Controller;
                    bBuildStlDeviceId = ParStlCheckIfStl( dummyPdx, daisyChainId );

                    if( bBuildStlDeviceId ) {
                        // SCM Micro device
                        ULONG DeviceIdSize;
                        devIdString = ParStlQueryStlDeviceId( dummyPdx, NULL, 0,&DeviceIdSize, TRUE );
                    } else {
                        // non-SCM Micro device
                        devIdString = P4ReadRawIeee1284DeviceId( controller );
                    }
                    ExFreePool( dummyPdx );
                }

                if( devIdString ) {
                    // got a 1284 device ID string from the device
                    PCHAR mfg, mdl, cls, des, aid, cid;
                    ParPnpFindDeviceIdKeys( &mfg, &mdl, &cls, &des, &aid, &cid, devIdString+2 );
                    if( mfg && mdl ) {
                        // we have a device, is it the same device?
                        if( (0 == strcmp( mfg, pdx->Mfg )) && (0 == strcmp( mdl, pdx->Mdl )) ) {
                            // same device
                            DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeDaisyChain %d - StillThere\n",daisyChainId);
                            deviceStillThere = TRUE;
                        } else {
                            // different device - IDs don't match
                            DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeDaisyChain %d - Gone - diff 1284 ID\n",daisyChainId);
                            deviceStillThere = FALSE;
                        }
                    } else {
                        // either mfg or mdl field not found
                        DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeDaisyChain %d - Gone - bad 1284 ID\n",daisyChainId);
                        deviceStillThere = FALSE;
                    }
                    // don't forget to free temp pool
                    ExFreePool( devIdString );
                    
                } else {
                    // unable to get a 1284 device ID string from the device
                    DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeDaisyChain %d - Gone - no 1284 ID\n",daisyChainId);
                    deviceStillThere = FALSE;
                }
                // don't forget to deselect device
                P5DeselectAllDaisyChainDevices( controller );
                
            } else {
                // unable to select device
                DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeDaisyChain %d - Gone - unable to select\n",daisyChainId);
                deviceStillThere = FALSE;
            }
        } // end new scope for case PdoTypeDaisyChain
        break;
            
    case PdoTypeEndOfChain:
        
        //
        // Pull a fresh 1284 device ID string from the device, and
        // compare the Mfg and Mdl from the fresh device ID with
        // those stored in our extension. If the Mfg and Mdl
        // fields match then the device is still there.
        //
        {
            ULONG        tryNumber = 0;
            const ULONG  maxTries  = 5; // arbitrary number

            do {

                ++tryNumber;

                devIdString = P4ReadRawIeee1284DeviceId( controller );            

                if( devIdString ) {
                    PCHAR mfg, mdl, cls, des, aid, cid;
                    ParPnpFindDeviceIdKeys( &mfg, &mdl, &cls, &des, &aid, &cid, devIdString+2 );
                    if( mfg && mdl ) {
                        // we have a device, is it the same device?
                        if( (0 == strcmp( mfg, pdx->Mfg )) && (0 == strcmp( mdl, pdx->Mdl )) ) {
                            // same device
                            DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeEndOfChain - StillThere\n");
                            deviceStillThere = TRUE;
                        } else {
                            // different device - IDs don't match
                            DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeEndOfChain - Gone - diff 1284 ID\n");
                            deviceStillThere = FALSE;
                        }
                    } else {
                        // either mfg or mdl field not found
                        DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeEndOfChain - Gone - bad 1284 ID\n");
                        deviceStillThere = FALSE;
                    }
                    // don't forget to free temp pool
                    ExFreePool( devIdString );
                } else {
                    // unable to get a 1284 device ID string from the device
                    DD((PCE)pdx,DDE,"P5IsDeviceStillThere - PdoTypeEndOfChain - Gone - no 1284 ID\n");
                    deviceStillThere = FALSE;
                }

                if( (FALSE == deviceStillThere ) && (PASSIVE_LEVEL == KeGetCurrentIrql()) ) {
                    LARGE_INTEGER delay;
                    delay.QuadPart = - 10 * 1000 * 120; // 120 ms - 3x the usual arbitrary delay 
                    KeDelayExecutionThread( KernelMode, FALSE, &delay);
                }

            } while( (FALSE == deviceStillThere) && (tryNumber < maxTries) );

        }
        break;
        
    default:
        
        PptAssertMsg("P5IsDeviceStillThere - invalid PdoType",FALSE);
        DD((PCE)Fdo,DDE,"P5IsDeviceStillThere - invalid PdoType\n");
        deviceStillThere = TRUE; // don't know what to do here - so, guess
    }
    
    return deviceStillThere;
}


NTSTATUS
PptAcquirePortViaIoctl(
    IN PDEVICE_OBJECT PortDeviceObject,
    IN PLARGE_INTEGER Timeout OPTIONAL
    )
/*++dvdf

Routine Description:

    This routine acquires the specified parallel port from the parallel 
      port arbiter ParPort via an IOCTL_INTERNAL_PARALLEL_PORT_ALLOCATE.

Arguments:

    PortDeviceObject - points to the ParPort device to be acquired

Return Value:

    STATUS_SUCCESS  - if the port was successfully acquired
    !STATUS_SUCCESS - otherwise

--*/
{
    LARGE_INTEGER    localTimeout;
    
    if( Timeout ) {
        localTimeout = *Timeout;           // caller specified
    } else {
        localTimeout = AcquirePortTimeout; // driver global variable default
    }

    return ParBuildSendInternalIoctl(IOCTL_INTERNAL_PARALLEL_PORT_ALLOCATE, 
                                     PortDeviceObject, NULL, 0, NULL, 0, &localTimeout);
}


NTSTATUS
PptReleasePortViaIoctl(
    IN PDEVICE_OBJECT PortDeviceObject
    )
/*++dvdf

Routine Description:

    This routine releases the specified parallel port back to the the parallel 
      port arbiter ParPort via an IOCTL_INTERNAL_PARALLEL_PORT_FREE.

Arguments:

    PortDeviceObject - points to the ParPort device to be released

Return Value:

    STATUS_SUCCESS  - if the port was successfully released
    !STATUS_SUCCESS - otherwise

--*/
{
    return ParBuildSendInternalIoctl(IOCTL_INTERNAL_PARALLEL_PORT_FREE, 
                                     PortDeviceObject, NULL, 0, NULL, 0, NULL);
}


VOID
PptWriteMfgMdlToDevNode(
    IN  PDEVICE_OBJECT  Pdo,
    IN  PCHAR           Mfg,
    IN  PCHAR           Mdl
    )
{
    PPDO_EXTENSION  pdx = Pdo->DeviceExtension;

    if( Mfg && Mdl ) {
    
        NTSTATUS  status;
        HANDLE    handle;
        LONG      mfgLen = strlen( Mfg );
        LONG      mdlLen = strlen( Mdl );
        LONG      maxLen = mfgLen > mdlLen ? mfgLen : mdlLen;
        LONG      bufLen = ( maxLen + sizeof(CHAR) ) * sizeof(WCHAR);
        PWSTR     buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, bufLen );

        if( buffer ) {

            status = IoOpenDeviceRegistryKey( Pdo, PLUGPLAY_REGKEY_DEVICE, KEY_ALL_ACCESS, &handle );
            
            if( STATUS_SUCCESS == status ) {
                UNICODE_STRING  uniValueName;
                LONG            wcharCount;
                
                //
                // Write MFG to DevNode
                //
                RtlInitUnicodeString( &uniValueName, L"IEEE_1284_Manufacturer" );
                wcharCount = _snwprintf( buffer, bufLen/sizeof(WCHAR), L"%S", Mfg );
                if( (wcharCount > 0) && (wcharCount < (LONG)(bufLen/sizeof(WCHAR))) ){
                    // no buffer overflow - continue
                    status = ZwSetValueKey( handle, &uniValueName, 0, REG_SZ, buffer, (wcharCount+1)*sizeof(WCHAR) );
                    PptAssert( STATUS_SUCCESS == status );
                } else {
                    // buffer overflow - skip writing this value to devnode
                    PptAssert(!"PptWriteMfgMdlToDevNode - buffer overflow on Mfg");
                    DD((PCE)pdx,DDW,"PptWriteMfgMdlToDevNode - buffer overflow on Mfg\n");
                }
                
                //
                // Write MDL to DevNode
                //
                RtlInitUnicodeString( &uniValueName, L"IEEE_1284_Model" );
                wcharCount = _snwprintf( buffer, bufLen/sizeof(WCHAR), L"%S", Mdl );
                if( (wcharCount > 0) && (wcharCount < (LONG)(bufLen/sizeof(WCHAR))) ){
                    // no buffer overflow - continue
                    status = ZwSetValueKey( handle, &uniValueName, 0, REG_SZ, buffer, (wcharCount+1)*sizeof(WCHAR) );
                    PptAssert( STATUS_SUCCESS == status );
                } else {
                    // buffer overflow - skip writing this value to devnode
                    PptAssert(!"PptWriteMfgMdlToDevNode - buffer overflow on Mdl");
                    DD((PCE)pdx,DDW,"PptWriteMfgMdlToDevNode - buffer overflow on Mdl\n");
                }
                
                ZwClose( handle );

            } else {
                DD((PCE)pdx,DDW,"PptWriteMfgMdlToDevNode - IoOpenDeviceRegistryKey FAILED - status = %x\n",status);
            }

            ExFreePool( buffer );

        } // end if( buffer )            

    } else {
        PptAssert(!"PptWriteMfgMdlToDevNode - Mfg or Mdl is NULL - calling function should catch this!");
        DD((PCE)pdx,DDW,"PptWriteMfgMdlToDevNode - Mfg or Mdl is NULL - calling function should catch this!");
    }
}


NTSTATUS
PptFdoHandleBusRelations(
    IN PDEVICE_OBJECT Fdo,
    IN PIRP           Irp
    )
{
    PFDO_EXTENSION     fdx         = Fdo->DeviceExtension;
    ULONG              deviceCount = 0;
    ULONG              daisyChainDevCount;
    PDEVICE_RELATIONS  devRel;
    ULONG              devRelSize;
    NTSTATUS           status;
    LARGE_INTEGER      acquirePortTimeout;
    BOOLEAN            acquiredPort;
    PUCHAR             controller  = fdx->PortInfo.Controller;
    BOOLEAN            changeDetected;

    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - enter\n");

    //
    // acquire exclusive access to bus
    //

    // timeout is in 100 ns units
    acquirePortTimeout.QuadPart = -(10 * 1000 * 1000 * 2); // 2 seconds
    
    // RMT - is it valid to send this IOCTL to FDO from here?
    status = PptAcquirePortViaIoctl( Fdo, &acquirePortTimeout );

    if( STATUS_SUCCESS == status ) {
        // we have the port
        acquiredPort = TRUE;
    } else {
        // failed to aquire port
        acquiredPort = FALSE;
        // skip rescanning port - just report same thing we reported during previous scan
        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - failed to acquire port for rescan\n");
        goto target_failed_to_acquire_port;
    }

    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - Port Acquired\n");

    //
    // Rescan the bus, note changes, create new PDOs or mark existing
    //   PDOs for removal as required
    //


    //
    // Handle Raw Port Legacy Interface LPTx device
    //
    if( !fdx->RawPortPdo ) {
        // first time through this - create our LPTx legacy interface PDO
        DD((PCE)fdx,DDT,"PptFdoHandleBusRelations - attempting to create RawPortPdo\n");
        fdx->RawPortPdo = P4CreatePdo( Fdo, PdoTypeRawPort, 0, NULL );
    }


    //
    // Handle End of Chain Device
    //

    // make sure all 1284.3 daisy chain devices are deselected
    P5DeselectAllDaisyChainDevices( controller );

    {
        // A small delay here seems to improve reliablility of 1284 device ID queries below.
        LARGE_INTEGER delay;
        delay.QuadPart = -1;
        KeDelayExecutionThread( KernelMode, FALSE, &delay );
    }

    if( fdx->EndOfChainPdo ) {

        if( fdx->DisableEndOfChainBusRescan ) {

            //
            // Pretend that the LPTx.4 device from previous rescan is still present.
            // 
            // This is needed to work around firmware state machines that can't handle a 
            // 1284 Device ID query while a print job is active.
            //

            ; // do nothing

        } else {

            //
            // we had an end of chain device - verify that it's still there
            //
            if( !P5IsDeviceStillThere( Fdo, fdx->EndOfChainPdo ) ) {
                // End of chain device is gone - do some cleanup and mark the PDO for removal/deletion
                DD((PCE)fdx,DDE,"PptFdoHandleBusRelations - EndOfChain device gone\n");
                // note - P5MarkPdoAsHardwareGone sets fdx->EndOfChainPdo to NULL
                P5MarkPdoAsHardwareGone( Fdo, PdoTypeEndOfChain, 0 );
            }
        }
    }

    if( NULL == fdx->EndOfChainPdo ) {
        //
        // we don't have an EndOfChain device - check for EndOfChain device arrival
        //
        PCHAR devId = P4ReadRawIeee1284DeviceId( controller );
        if( devId ) {
            // RawIeee1284 string includes 2 bytes of length data at beginning, omit these 2 bytes in call to P4CreatePdo
            PDEVICE_OBJECT EndOfChainPdo = P4CreatePdo( Fdo, PdoTypeEndOfChain, 0, (devId+2) );
            DD((PCE)fdx,DDE,"PptFdoHandleBusRelations - EndOfChain device detected <%s>\n",(devId+2));
            if( EndOfChainPdo ) {
                fdx->EndOfChainPdo = EndOfChainPdo;
                DD((PCE)fdx,DDE,"PptFdoHandleBusRelations - created EndOfChainPdo\n");
            } else {
                DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - FAILED to create EndOfChainPdo\n");
            }
            ExFreePool( devId );
        }
    }


#ifdef _X86_ // Zip drives not supported on 64bit systems

    //
    // Handle Legacy Zip device
    //

    if( fdx->LegacyZipPdo ) {
        //
        // we had a Legacy Zip device - verify that it's still there
        //
        if( !P5IsDeviceStillThere( Fdo, fdx->LegacyZipPdo ) ) {
            // Legacy Zip device is gone - do some cleanup and mark the PDO for removal/deletion
            DD((PCE)fdx,DDE,"PptFdoHandleBusRelations - LegacyZip device gone\n");
            // note - P5MarkPdoAsHardwareGone sets fdx->LegacyZipPdo to NULL
            P5MarkPdoAsHardwareGone( Fdo, PdoTypeLegacyZip, 0 );
        }
    }

    if( NULL == fdx->LegacyZipPdo ) {
        // 
        // We don't have a LegacyZip - check for arrival
        //
        if( !ParEnableLegacyZip ) {
            
            //
            // Enumeration of LegacyZip drives was disabled, check the
            //   registry to see if user has enabled LegacyZip detection
            // 
            
            // Check under \HKLM\SYSTEM\CCS\Services\Parport\Parameters
            PptRegGetDword( RTL_REGISTRY_SERVICES, L"Parport\\Parameters", L"ParEnableLegacyZip", &ParEnableLegacyZip );
            
            if( !ParEnableLegacyZip ) {
                // Check under \HKLM\SYSTEM\CCS\Services\Parallel\Parameters (upgrade case - under Win2k flag was here)
                PptRegGetDword( RTL_REGISTRY_SERVICES, L"Parallel\\Parameters", L"ParEnableLegacyZip", &ParEnableLegacyZip );
                
                if( ParEnableLegacyZip ) {
                    // we found the setting in the old location, save
                    //   setting in new Parport location so that we find the
                    //   flag on the first check in the future
                    PptRegSetDword( RTL_REGISTRY_SERVICES, L"Parport\\Parameters", L"ParEnableLegacyZip", &ParEnableLegacyZip );
                }
            }
        } 
        
        if( ParEnableLegacyZip ) {
            
            //
            // Enumeration of LegacyZip drives is enabled - check for a LegacyZip arrival
            //
            
            if( P5LegacyZipDetected( controller ) ) {
                // detected drive - create LegacyZip PDO
                PDEVICE_OBJECT legacyZipPdo = P4CreatePdo( Fdo, PdoTypeLegacyZip, 0, NULL );
                DD((PCE)fdx,DDE,"legacy Zip arrival detected\n");
                if( legacyZipPdo ) {
                    fdx->LegacyZipPdo = legacyZipPdo;
                    DD((PCE)fdx,DDE,"PptFdoHandleBusRelations - created LegacyZipPdo\n");
                } else {
                    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - FAILED to create LegacyZipPdo\n");
                }
            } else {
                // no legacy Zip detected - nothing more to do here
                DD((PCE)fdx,DDE,"no legacy Zip detected\n");
            }

        } // if( ParEnableLegacyZip ) -- Detection of LegacyZips is enabled

    } // if( fdx->LegacyZipPdo )


    //
    // Handle enumeration of IEEE 1284.3 Daisy Chain Devices
    //

    // did the 1284.3 daisy chain change since the last rescan?
    daisyChainDevCount = PptInitiate1284_3( fdx );
    DD((PCE)fdx,DDW,"daisyChainDevCount = %d\n",daisyChainDevCount);

    changeDetected = FALSE;

    {
        ULONG id;
        const ULONG maxId = 1;
        ULONG count = 0;
        for( id = 0 ; id <= maxId ; ++id ) {
            if( fdx->DaisyChainPdo[id] ) {
                ++count;
            }
        }
        if( count != daisyChainDevCount ) {
            // number of devices changed from previous scan
            DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - number of DC devices changed - count=%d, daisyChainDevCount=%d\n",
               count, daisyChainDevCount);
            changeDetected = TRUE;
        }
    }
    
    if( !changeDetected ) {
        // number of devices stayed the same - are any of the devices different?
        //
        // number of daisy chain devices didn't change
        // check if any of the devices changed
        ULONG id;
        const ULONG maxId = 1;
        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - number of DC devices stayed same - check the devices\n");
        for( id = 0 ; id <= maxId ; ++id ) {
            if( fdx->DaisyChainPdo[id] && !P5IsDeviceStillThere( Fdo, fdx->DaisyChainPdo[id] ) ) {
                DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - a DC device changed\n");
                changeDetected = TRUE;
                break;
            }
        }
    }


    if( changeDetected ) {
        // we detected a change in the 1284.3 daisy chain devices - nuke all existing devices
        ULONG id;
        const ULONG maxId = 1;
        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - changeDetected - nuking existing daisy chain PDOs\n");
        for( id = 0 ; id <= maxId ; ++id ) {
            if( fdx->DaisyChainPdo[id] ) {
                DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - nuking daisy chain %d\n",id);
                P5MarkPdoAsHardwareGone( Fdo, PdoTypeDaisyChain, id );
                PptAssert( NULL == fdx->DaisyChainPdo[id] );
            }
        }
        fdx->PnpInfo.Ieee1284_3DeviceCount = 0;
    } else {
        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - !changeDetected in daisy chain PDOs\n");
    }

    // reinit daisy chain and assign addresses
    daisyChainDevCount = PptInitiate1284_3( fdx );
    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - daisyChainDevCount = %d\n",daisyChainDevCount);
    if( daisyChainDevCount > 2 ) {
        // we only support 2 devices per port even though the spec supports up to 4 devices per port
        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - DaisyChainDevCount > 2, set to 2\n");
        daisyChainDevCount = 2;
    }

    if( changeDetected ) {
        // we detected a change in the 1284.3 daisy chain devices - we
        // previously nuked all old devices - now create a new PDO for
        // each device detected
        UCHAR id;
        PptAssert( 0 == fdx->PnpInfo.Ieee1284_3DeviceCount );
        for( id = 0 ; id < daisyChainDevCount ; ++id ) {

            BOOLEAN         bBuildStlDeviceId = FALSE;
            PPDO_EXTENSION  pdx               = NULL;


            DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - changeDetected - trying to create new daisy chain PDOs\n");

            if( P5SelectDaisyChainDevice( controller, id ) ) {

                PCHAR devId = NULL;

                // do a check to see if this is an SCM Micro device
                pdx = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, sizeof(PDO_EXTENSION) );
                if( pdx != NULL ) {
                    RtlZeroMemory( pdx, sizeof(PDO_EXTENSION) );
                    pdx->Controller   = fdx->PortInfo.Controller;
                    bBuildStlDeviceId = ParStlCheckIfStl( pdx, id );
                    ExFreePool( pdx );
                }


                if( bBuildStlDeviceId ) {
                    
                    // SCM Micro device
                    pdx = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, sizeof(PDO_EXTENSION) );
                    if( pdx != NULL ) {
                        ULONG DeviceIdSize;
                        RtlZeroMemory( pdx, sizeof(PDO_EXTENSION) );
                        pdx->Controller = fdx->PortInfo.Controller;
                        devId = ParStlQueryStlDeviceId(pdx, NULL, 0,&DeviceIdSize, TRUE);
                        ExFreePool (pdx);
                    }
                    
                } else {

                    // non-SCM Micro device
                    devId = P4ReadRawIeee1284DeviceId( controller );

                }

                if( devId ) {

                    // try to create a PDO for the daisy chain device
                    fdx->DaisyChainPdo[id] = P4CreatePdo( Fdo, PdoTypeDaisyChain, id, (devId+2) );

                    if( fdx->DaisyChainPdo[id] ) {
                        // have new PDO
                        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - new DaisyChainPdo[%d]\n",id);
                        ++(fdx->PnpInfo.Ieee1284_3DeviceCount);
                        
                        if( bBuildStlDeviceId ) {
                            // SCM Micro device - requires additional initialization
                            DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - new SCM Micro DaisyChainPdo[%d]\n",id);
                            pdx = fdx->DaisyChainPdo[id]->DeviceExtension;
                            pdx->Controller = fdx->PortInfo.Controller;
                            ParStlCheckIfStl( pdx, 0 ); // update IEEE 1284 flags in the new pdx
                        }

                    } else {
                        // create PDO failed
                        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - create DaisyChainPdo[%d] failed\n",id);
                    }
                    ExFreePool( devId );
                } else {
                    // devId failed
                    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - devId for DC %d failed\n",id);
                }
                P5DeselectAllDaisyChainDevices( controller );
            } else {
                // select failed
                DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - select for DC %d failed\n",id);
            }
        }
    }

    {
        ULONG i;
        ULONG count = 0;
        i = 0;
        for( i = 0 ; i < 2 ; ++i ) {
            if( fdx->DaisyChainPdo[i] ) {
                ++count;
            }
        }
        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - Ieee1284_3DeviceCount=%d  count1 = %d\n",
           fdx->PnpInfo.Ieee1284_3DeviceCount,count);
        PptAssert( fdx->PnpInfo.Ieee1284_3DeviceCount == count );
    }

    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - daisyChainDevCount = %d, fdx->PnpInfo.Ieee1284_3DeviceCount = %d\n",
       daisyChainDevCount, fdx->PnpInfo.Ieee1284_3DeviceCount);

    // PptAssert( daisyChainDevCount == fdx->PnpInfo.Ieee1284_3DeviceCount );

#endif // _X86_

target_failed_to_acquire_port: // jump here if we couldn't get the port - result is that we report that nothing has changed

    //
    // Count the number of devices that we are going to report to PnP
    //   so that we can allocate a DEVICE_RELATIONS structure of the
    //   appropriate size.
    //

    if( fdx->RawPortPdo ) {
        ++deviceCount;
    }

    if( fdx->EndOfChainPdo ) {
        ++deviceCount;
    }

    if( fdx->LegacyZipPdo ) {
        ++deviceCount;
    }

    {
        const ULONG maxDaisyChainId = 1;
        ULONG i;
        for( i=0 ; i <= maxDaisyChainId; ++i ) {
            if( fdx->DaisyChainPdo[i] ) {
                ++deviceCount;
            } else {
                break;
            }
        }
    }

    if( deviceCount > 0 && fdx->RawPortPdo ) {

        //
        // Allocate and populate DEVICE_RELATIONS structure that we return to PnP
        //
        
        devRelSize = sizeof(DEVICE_RELATIONS) + (deviceCount-1)*sizeof(PDEVICE_OBJECT);
        devRel     = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, devRelSize );
        
        if( !devRel ) {
            // release port and fail IRP
            P4ReleaseBus( Fdo );
            return P4CompleteRequestReleaseRemLock( Irp, STATUS_INSUFFICIENT_RESOURCES, Irp->IoStatus.Information, &fdx->RemoveLock );
        }
        
        { // local block - begin
            ULONG idx = 0;
            
            RtlZeroMemory( devRel, devRelSize );
            
            ++(devRel->Count);
            ObReferenceObject( fdx->RawPortPdo );
            devRel->Objects[ idx++ ] = fdx->RawPortPdo;
            
            if( fdx->EndOfChainPdo ) {
                ++(devRel->Count);
                ObReferenceObject( fdx->EndOfChainPdo );
                devRel->Objects[ idx++ ] = fdx->EndOfChainPdo;
            }
            
            if( fdx->LegacyZipPdo ) {
                ++(devRel->Count);
                ObReferenceObject( fdx->LegacyZipPdo );
                devRel->Objects[ idx++ ] = fdx->LegacyZipPdo;
            }
            
            {
                const ULONG maxDaisyChainId = 3;
                ULONG       i;
                
                for( i=0 ; i <= maxDaisyChainId; ++i ) {
                    if( fdx->DaisyChainPdo[i] ) {
                        ++(devRel->Count);
                        ObReferenceObject( fdx->DaisyChainPdo[i] );
                        devRel->Objects[ idx++ ] = fdx->DaisyChainPdo[i];
                    } else {
                        break;
                    }
                }
            }
            
        } // local block - end
        
        PptAssert( deviceCount == devRel->Count ); // verify that our two counts match
        
        DD((PCE)fdx,DDE,"PptFdoHandleBusRelations - reporting %d devices\n",devRel->Count);
        
        Irp->IoStatus.Status      = STATUS_SUCCESS;
        Irp->IoStatus.Information = (ULONG_PTR)devRel;
    } else {
        // deviceCount <= 0 - error somewhere - likely two ports
        //   have the same LPTx name in the FDO stack's devnode

        // RMT - this assert needs to be changed to ErrorLog msg 
        PptAssert(!"no RawPort device - likely multiple ports have same LPTx name - email: DFritz");
    }


    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - passing IRP down stack\n");

    status = PptPnpPassThroughPnpIrpAndReleaseRemoveLock( fdx, Irp );

    //
    // Release our lock on the bus and pass Irp down the stack
    //
    if( acquiredPort ) {
        PIO_WORKITEM workItem = IoAllocateWorkItem( Fdo );
        if( workItem ) {

            PIO_WORKITEM oldWorkItem = InterlockedCompareExchangePointer( &fdx->FreePortWorkItem, workItem, NULL );
            if( NULL == oldWorkItem ) {

                // no workitem currently in use, queue this one
                IoQueueWorkItem( workItem, P5WorkItemFreePort, DelayedWorkQueue, fdx );

            } else {

                // there is already a workitem in use, bail out and recover as best we can

                // We really shouldn't be able to get here - how in blazes did we
                // acquire the port at the top of this function if the workitem
                // that we queued to free the port during the previous invocation
                // of this function has not yet freed the port?

                PptAssertMsg( "workitem collision - port arbitration state may be hosed", (oldWorkItem != NULL) );
                IoFreeWorkItem( workItem );
                PptFreePort( fdx );

            }

        } else {
            PptFreePort( fdx );
        }
        // DbgPrint("xxx work item to free port has been queued\n");
        //DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - Releasing Port\n");
        //PptFreePort( fdx );
        //DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - Port Released\n");
    } else {
        DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - Port Not acquired so no need to release\n");
    }

    DD((PCE)fdx,DDW,"PptFdoHandleBusRelations - exit\n");

    return status;
}

NTSTATUS
PptPnpStartScanPciCardCmResourceList(
    IN  PFDO_EXTENSION Fdx,
    IN  PIRP              Irp, 
    OUT PBOOLEAN          FoundPort,
    OUT PBOOLEAN          FoundIrq,
    OUT PBOOLEAN          FoundDma
    )
/*++dvdf3

Routine Description:

    This routine is used to parse the resource list for what we
      believe are PCI parallel port cards.

    This function scans the CM_RESOURCE_LIST supplied with the Pnp 
      IRP_MN_START_DEVICE IRP, extracts the resources from the list, 
      and saves them in the device extension.

Arguments:

    Fdx    - The device extension of the target of the START IRP
    Irp          - The IRP
    FoundPort    - Did we find a  Port resource?
    FoundIrq     - Did we find an IRQ  resource?
    FoundDma     - Did we find a  DMA  resource?

Return Value:

    STATUS_SUCCESS                - if we were given a resource list,
    STATUS_INSUFFICIENT_RESOURCES - otherwise

--*/
{
    NTSTATUS                        status   = STATUS_SUCCESS;
    PIO_STACK_LOCATION              irpStack = IoGetCurrentIrpStackLocation( Irp );
    PCM_RESOURCE_LIST               ResourceList;
    PCM_FULL_RESOURCE_DESCRIPTOR    FullResourceDescriptor;
    PCM_PARTIAL_RESOURCE_LIST       PartialResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResourceDescriptor;
    ULONG                           i;
    ULONG                           length;
    
    *FoundPort = FALSE;
    *FoundIrq  = FALSE;
    *FoundDma  = FALSE;
    
    ResourceList = irpStack->Parameters.StartDevice.AllocatedResourcesTranslated;
    
    FullResourceDescriptor = &ResourceList->List[0];
    
    if( FullResourceDescriptor ) {
        
        Fdx->InterfaceType = FullResourceDescriptor->InterfaceType;
        
        PartialResourceList = &FullResourceDescriptor->PartialResourceList;
        
        for (i = 0; i < PartialResourceList->Count; i++) {
            
            PartialResourceDescriptor = &PartialResourceList->PartialDescriptors[i];
            
            switch (PartialResourceDescriptor->Type) {
                
            case CmResourceTypePort:
                
                length = PartialResourceDescriptor->u.Port.Length;

                //
                // Use a heuristic based on length to guess which register set is
                //   SPP+EPP, which is ECP, and which is PCI Config or other.
                //
                switch( length ) {

                case 8: // SPP + EPP base address

                    Fdx->PortInfo.OriginalController = PartialResourceDescriptor->u.Port.Start;
                    Fdx->PortInfo.SpanOfController   = PartialResourceDescriptor->u.Port.Length;
                    Fdx->PortInfo.Controller         = (PUCHAR)(ULONG_PTR)Fdx->PortInfo.OriginalController.QuadPart;
                    Fdx->AddressSpace                = PartialResourceDescriptor->Flags;
                    *FoundPort = TRUE;
                    break;

                case 4: // ECP base address
                    
                    Fdx->PnpInfo.OriginalEcpController = PartialResourceDescriptor->u.Port.Start;
                    Fdx->PnpInfo.SpanOfEcpController   = PartialResourceDescriptor->u.Port.Length;
                    Fdx->PnpInfo.EcpController         = (PUCHAR)(ULONG_PTR)Fdx->PnpInfo.OriginalEcpController.QuadPart;
                    Fdx->EcpAddressSpace               = PartialResourceDescriptor->Flags;
                    break;

                default:
                    // don't know what this is - ignore it
                    ;
                }
                break;
                
            case CmResourceTypeBusNumber:
                
                Fdx->BusNumber = PartialResourceDescriptor->u.BusNumber.Start;
                break;
                
            case CmResourceTypeInterrupt:
                
                *FoundIrq = TRUE;
                Fdx->FoundInterrupt       = TRUE;
                Fdx->InterruptLevel       = (KIRQL)PartialResourceDescriptor->u.Interrupt.Level;
                Fdx->InterruptVector      = PartialResourceDescriptor->u.Interrupt.Vector;
                Fdx->InterruptAffinity    = PartialResourceDescriptor->u.Interrupt.Affinity;
                
                if (PartialResourceDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED) {
                    
                    Fdx->InterruptMode = Latched;
                    
                } else {
                    
                    Fdx->InterruptMode = LevelSensitive;
                }
                break;
                
            case CmResourceTypeDma:
                
                // we don't do anything with DMA - fall through to default case
                
            default:

                break;

            } // end switch( PartialResourceDescriptor->Type )
        } // end for(... ; i < PartialResourceList->Count ; ...)
    } // end if( FullResourceDescriptor )
    
    return status;
}

BOOLEAN PptIsPci(
    PFDO_EXTENSION Fdx, 
    PIRP              Irp 
)
/*++

Does this look like a PCI card? Return TRUE if yes, FALSE otherwise

--*/
{
    PIO_STACK_LOCATION              irpStack = IoGetCurrentIrpStackLocation( Irp );
    PCM_RESOURCE_LIST               ResourceList;
    PCM_FULL_RESOURCE_DESCRIPTOR    FullResourceDescriptor;
    PCM_PARTIAL_RESOURCE_LIST       PartialResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResourceDescriptor;
    ULONG                           i;
    ULONG                           portResourceDescriptorCount = 0;
    BOOLEAN                         largePortRangeFound         = FALSE;
    ULONG                           rangeLength;
    
    //
    // If there are more than 2 IO resource descriptors, or if any IO resource
    //   descriptor has a range > 8 bytes, then assume that this is a PCI device
    //   and requires non-traditional handling.
    //

    ResourceList = irpStack->Parameters.StartDevice.AllocatedResourcesTranslated;
    
    if (ResourceList == NULL) {
        // we weren't given any resources
        return FALSE;
    }

    FullResourceDescriptor = &ResourceList->List[0];
    
    if (FullResourceDescriptor) {
        
        PartialResourceList = &FullResourceDescriptor->PartialResourceList;
        
        for (i = 0; i < PartialResourceList->Count; i++) {
            
            PartialResourceDescriptor = &PartialResourceList->PartialDescriptors[i];
            
            switch (PartialResourceDescriptor->Type) {
                
            case CmResourceTypePort:
                
                rangeLength = PartialResourceDescriptor->u.Port.Length;
                DD((PCE)Fdx,DDT,"pnp::PptIsPCI - CmResourceTypePort - Start= %I64x, Length= %x , \n",
                                       PartialResourceDescriptor->u.Port.Start.QuadPart, rangeLength);

                ++portResourceDescriptorCount;

                if( rangeLength > 8 ) {
                    largePortRangeFound = TRUE;
                }
                break;
                
            default:
                ;
            } // end switch( PartialResourceDescriptor->Type )
        } // end for(... ; i < PartialResourceList->Count ; ...)
    } // end if( FullResourceDescriptor )
    
    if( (portResourceDescriptorCount > 2) || (TRUE == largePortRangeFound) ) {
        // looks like PCI
        return TRUE;
    } else {
        // does not look like PCI
        return FALSE;
    }
}

NTSTATUS
PptPnpStartScanCmResourceList(
    IN  PFDO_EXTENSION Fdx,
    IN  PIRP              Irp, 
    OUT PBOOLEAN          FoundPort,
    OUT PBOOLEAN          FoundIrq,
    OUT PBOOLEAN          FoundDma
    )
/*++dvdf3

Routine Description:

    This function is a helper function called by PptPnpStartDevice(). 

    This function scans the CM_RESOURCE_LIST supplied with the Pnp 
      IRP_MN_START_DEVICE IRP, extracts the resources from the list, 
      and saves them in the device Fdx.

Arguments:

    Fdx    - The device extension of the target of the START IRP
    Irp          - The IRP
    FoundPort    - Did we find a  Port resource?
    FoundIrq     - Did we find an IRQ  resource?
    FoundDma     - Did we find a  DMA  resource?

Return Value:

    STATUS_SUCCESS                - if we were given a resource list,
    STATUS_INSUFFICIENT_RESOURCES - otherwise

--*/
{
    NTSTATUS                        status   = STATUS_SUCCESS;
    PIO_STACK_LOCATION              irpStack = IoGetCurrentIrpStackLocation( Irp );
    PCM_RESOURCE_LIST               ResourceList;
    PCM_FULL_RESOURCE_DESCRIPTOR    FullResourceDescriptor;
    PCM_PARTIAL_RESOURCE_LIST       PartialResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResourceDescriptor;
    ULONG                           i;
    PHYSICAL_ADDRESS                start;
    ULONG                           length;
    BOOLEAN                         isPci = FALSE;
    
    *FoundPort = FALSE;
    *FoundIrq  = FALSE;
    *FoundDma  = FALSE;
    
    ResourceList = irpStack->Parameters.StartDevice.AllocatedResourcesTranslated;
    
    if (ResourceList == NULL) {
        // we weren't given any resources, bail out
        DD((PCE)Fdx,DDT,"START - FAIL - No Resources - AllocatedResourcesTranslated == NULL\n");
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto targetExit;
    }

    if( TRUE == PptIsPci( Fdx, Irp ) ) {
        // This appears to be a PCI card
        status = PptPnpStartScanPciCardCmResourceList(Fdx, Irp, FoundPort, FoundIrq, FoundDma);
        isPci=TRUE;
        goto targetExit;
    }
    
    //
    // Device appears to be traditional / non-PCI card parallel port
    //

    FullResourceDescriptor = &ResourceList->List[0];
    
    if (FullResourceDescriptor) {
        
        Fdx->InterfaceType = FullResourceDescriptor->InterfaceType;
        
        PartialResourceList = &FullResourceDescriptor->PartialResourceList;
        
        for (i = 0; i < PartialResourceList->Count; i++) {
            
            PartialResourceDescriptor = &PartialResourceList->PartialDescriptors[i];
            
            switch (PartialResourceDescriptor->Type) {
                
            case CmResourceTypePort:
                
                start  = PartialResourceDescriptor->u.Port.Start;
                length = PartialResourceDescriptor->u.Port.Length;
                DD((PCE)Fdx,DDT,"pnp::PptPnpStartScanCmResourceList - start= %I64x , length=%x\n",start, length);

                *FoundPort = TRUE;
                if ((Fdx->PortInfo.OriginalController.LowPart == 0) &&
                    (Fdx->PortInfo.OriginalController.HighPart == 0)) {
                    
                    DD((PCE)Fdx,DDT,"pnp::PptPnpStartScanCmResourceList - assuming Controller\n");

                    Fdx->PortInfo.OriginalController = PartialResourceDescriptor->u.Port.Start;
                    Fdx->PortInfo.SpanOfController   = PartialResourceDescriptor->u.Port.Length;
                    Fdx->PortInfo.Controller         = (PUCHAR)(ULONG_PTR)Fdx->PortInfo.OriginalController.QuadPart;
                    Fdx->AddressSpace                = PartialResourceDescriptor->Flags;
                    
                } else if ((Fdx->PnpInfo.OriginalEcpController.LowPart == 0) &&
                           (Fdx->PnpInfo.OriginalEcpController.HighPart == 0) &&
                           (IsNotNEC_98)) {
                    
                    if ((PartialResourceDescriptor->u.Port.Start.LowPart < Fdx->PortInfo.OriginalController.LowPart) &&
                        (PartialResourceDescriptor->u.Port.Start.HighPart < Fdx->PortInfo.OriginalController.HighPart)) {
                        
                        //
                        // Swapping address spaces
                        //
                        
                        DD((PCE)Fdx,DDT,"pnp::PptPnpStartScanCmResourceList - assuming Controller - Swapping Controller/EcpController\n");

                        Fdx->PnpInfo.OriginalEcpController = Fdx->PortInfo.OriginalController;
                        Fdx->PnpInfo.SpanOfEcpController   = Fdx->PortInfo.SpanOfController;
                        Fdx->PnpInfo.EcpController         = Fdx->PortInfo.Controller;
                        Fdx->EcpAddressSpace               = Fdx->AddressSpace;
                        
                        Fdx->PortInfo.OriginalController = PartialResourceDescriptor->u.Port.Start;
                        Fdx->PortInfo.SpanOfController   = PartialResourceDescriptor->u.Port.Length;
                        Fdx->PortInfo.Controller         = (PUCHAR)(ULONG_PTR)Fdx->PortInfo.OriginalController.QuadPart;
                        Fdx->AddressSpace                = PartialResourceDescriptor->Flags;
                        
                    } else {
                        DD((PCE)Fdx,DDT,"pnp::PptPnpStartScanCmResourceList - assuming EcpController\n");

                        Fdx->PnpInfo.OriginalEcpController = PartialResourceDescriptor->u.Port.Start;
                        Fdx->PnpInfo.SpanOfEcpController   = PartialResourceDescriptor->u.Port.Length;
                        Fdx->PnpInfo.EcpController         = (PUCHAR)(ULONG_PTR)Fdx->PnpInfo.OriginalEcpController.QuadPart;
                        Fdx->EcpAddressSpace               = PartialResourceDescriptor->Flags;
                    }
                    
                }
                break;
                
            case CmResourceTypeBusNumber:
                
                Fdx->BusNumber = PartialResourceDescriptor->u.BusNumber.Start;
                break;
                
            case CmResourceTypeInterrupt:
                
                *FoundIrq = TRUE;
                Fdx->FoundInterrupt       = TRUE;
                Fdx->InterruptLevel       = (KIRQL)PartialResourceDescriptor->u.Interrupt.Level;
                Fdx->InterruptVector      = PartialResourceDescriptor->u.Interrupt.Vector;
                Fdx->InterruptAffinity    = PartialResourceDescriptor->u.Interrupt.Affinity;
                
                if (PartialResourceDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED) {
                    
                    Fdx->InterruptMode = Latched;
                    
                } else {
                    
                    Fdx->InterruptMode = LevelSensitive;
                }
                break;
                
            case CmResourceTypeDma:

                // we don't do anything with DMA - fall through to default case

            default:

                break;

            } // end switch( PartialResourceDescriptor->Type )
        } // end for(... ; i < PartialResourceList->Count ; ...)
    } // end if( FullResourceDescriptor )
    
targetExit:

    if( FALSE == isPci ) {
        // we scanned the resources - dump what we found
        DD((PCE)Fdx,DDT,"pnp::PptPnpStartScanCmResourceList - done, found:\n");
        DD((PCE)Fdx,DDT,"  OriginalEcpController= %I64x\n", Fdx->PnpInfo.OriginalEcpController);
        DD((PCE)Fdx,DDT,"  EcpController        = %p\n",    Fdx->PnpInfo.EcpController);
        DD((PCE)Fdx,DDT,"  SpanOfEcpController  = %x\n",    Fdx->PnpInfo.SpanOfEcpController);
    }
    return status;
}

NTSTATUS
PptPnpStartValidateResources(
    IN PDEVICE_OBJECT    DeviceObject,                              
    IN BOOLEAN           FoundPort,
    IN BOOLEAN           FoundIrq,
    IN BOOLEAN           FoundDma
    )
/*++dvdf3

Routine Description:

    This function is a helper function called by PptPnpStartDevice(). 

    This function does a sanity check of the resources saved in our
      extension by PptPnpStartScanCmResourceList() to determine 
      if those resources appear to be valid. Checks for for Irq 
      and Dma resource validity are anticipated in a future version.

Arguments:

    DeviceObject - The target of the START IRP
    FoundPort    - Did we find a  Port resource?
    FoundIrq     - Did we find an IRQ  resource?
    FoundDma     - Did we find a  DMA  resource?

Return Value:

    STATUS_SUCCESS        - on success,
    STATUS_NO_SUCH_DEVICE - if we weren't given a port resource,
    STATUS_NONE_MAPPED    - if we were given a port resource but our 
                              port address is NULL

--*/
{
    PFDO_EXTENSION fdx = DeviceObject->DeviceExtension;
    NTSTATUS          status    = STATUS_SUCCESS;

    UNREFERENCED_PARAMETER( FoundIrq ); // future use
    UNREFERENCED_PARAMETER( FoundDma ); // future use

    if( !FoundPort ) {
        status = STATUS_NO_SUCH_DEVICE;
    } else {
//         fdx->PortInfo.Controller = (PUCHAR)(ULONG_PTR)fdx->PortInfo.OriginalController.LowPart;
        fdx->PortInfo.Controller = (PUCHAR)(ULONG_PTR)fdx->PortInfo.OriginalController.QuadPart;

        if(!fdx->PortInfo.Controller) {
            // ( Controller == NULL ) is invalid
            PptLogError(DeviceObject->DriverObject, DeviceObject,
                        fdx->PortInfo.OriginalController, PhysicalZero, 0, 0, 0, 10,
                        STATUS_SUCCESS, PAR_REGISTERS_NOT_MAPPED);
            status = STATUS_NONE_MAPPED;
        }
    }
    return status;
}


BOOLEAN
PptPnpFilterExistsNonIrqResourceList(
    IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirementsList
    )
/*++dvdf8

Routine Description:

    This function is a helper function called by 
      PptPnpFilterResourceRequirements(). 

    This function scans the IO_RESOURCE_REQUIREMENTS_LIST to determine
      whether there exists any resource alternatives that do NOT contain
      an IRQ resource descriptor. The method used to filter out IRQ
      resources may differ based on whether or not there exists a
      resource alternative that does not contain an IRQ resource
      descriptor.

Arguments:

    ResourceRequirementsList - The list to scan.

Return Value:

    TRUE  - There exists at least one resource alternative in the list that
              does not contain an IRQ resource descriptor.
    FALSE - Otherwise.           

--*/
{
    ULONG listCount = ResourceRequirementsList->AlternativeLists;
    PIO_RESOURCE_LIST curList;
    ULONG i;

    i=0;
    curList = ResourceRequirementsList->List;
    while( i < listCount ) {
        DD(NULL,DDT,"Searching List i=%d for an IRQ, curList= %x\n", i,curList);
        {
            ULONG                   remain   = curList->Count;
            PIO_RESOURCE_DESCRIPTOR curDesc  = curList->Descriptors;
            BOOLEAN                 foundIrq = FALSE;
            while( remain ) {
                DD(NULL,DDT," curDesc= %x , remain=%d\n", curDesc, remain);
                if(curDesc->Type == CmResourceTypeInterrupt) {
                    DD(NULL,DDT," Found IRQ - skip to next list\n");
                    foundIrq = TRUE;
                    break;
                }
                ++curDesc;
                --remain;
            }
            if( foundIrq == FALSE ) {
                //
                // We found a resource list that does not contain an IRQ resource. 
                //   Our search is over.
                //
                DD(NULL,DDT," Found a list with NO IRQ - return TRUE from PptPnpFilterExistsNonIrqResourceList\n");
                return TRUE;
            }
        }
        //
        // The next list starts immediately after the last descriptor of the current list.
        //
        curList = (PIO_RESOURCE_LIST)(curList->Descriptors + curList->Count);
        ++i;
    }

    //
    // All resource alternatives contain at least one IRQ resource descriptor.
    //
    DD(NULL,DDT,"all lists contain IRQs - return FALSE from PptPnpFilterExistsNonIrqResourceList\n");
    return FALSE;
}

VOID
PptPnpFilterRemoveIrqResourceLists(
    PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirementsList
    )
/*++dvdf8

Routine Description:

    This function is a helper function called by 
      PptPnpFilterResourceRequirements(). 

    This function removes all resource alternatives (IO_RESOURCE_LISTs) 
      that contain IRQ resources from the IO_RESOURCE_REQUIREMENTS_LIST 

Arguments:

    ResourceRequirementsList - The list to process.

Return Value:

    none.

--*/
{
    ULONG listCount = ResourceRequirementsList->AlternativeLists;
    PIO_RESOURCE_LIST curList;
    PIO_RESOURCE_LIST nextList;
    ULONG i;
    PCHAR currentEndOfResourceRequirementsList;
    LONG bytesToMove;

    DD(NULL,DDT,"Enter PptPnpFilterRemoveIrqResourceLists() - AlternativeLists= %d\n", listCount);

    //
    // We use the end of the list to compute the size of the memory
    //   block to move when we remove a resource alternative from the
    //   list of lists.
    //
    currentEndOfResourceRequirementsList = PptPnpFilterGetEndOfResourceRequirementsList(ResourceRequirementsList);

    i=0;
    curList = ResourceRequirementsList->List;

    //
    // Walk through the IO_RESOURCE_LISTs.
    //
    while( i < listCount ) {

        if( PptPnpListContainsIrqResourceDescriptor(curList) ) {
            //
            // The current list contains IRQ, remove it by shifting the 
            //   remaining lists into its place and decrementing the list count.
            //

            DD(NULL,DDT,"list contains an IRQ - Removing List\n");

            //
            // Get a pointer to the start of the next list.
            //
            nextList = (PIO_RESOURCE_LIST)(curList->Descriptors + curList->Count);

            //
            // compute the number of bytes to move
            //
            bytesToMove = (LONG)(currentEndOfResourceRequirementsList - (PCHAR)nextList);

            //
            // if (currentEndOfResourceRequirementsList == next list), 
            //   then this is the last list so there is nothing to move.
            //
            if( bytesToMove > 0 ) {
                //
                // More lists remain - shift them into the hole.
                //
                RtlMoveMemory(curList, nextList, bytesToMove);

                //
                // Adjust the pointer to the end of of the 
                //   IO_RESOURCE_REQUIREMENTS_LIST (list of lists) due to the shift.
                //
                currentEndOfResourceRequirementsList -= ( (PCHAR)nextList - (PCHAR)curList );
            }

            //
            // Note that we removed an IO_RESOURCE_LIST from the IO_RESOURCE_REQUIREMENTS_LIST.
            //
            --listCount;

        } else {
            //
            // The current list does not contain an IRQ resource, advance to next list.
            //
            DD(NULL,DDT,"list does not contain an IRQ - i=%d listCount=%d curList= %#x\n", i,listCount,curList);
            curList = (PIO_RESOURCE_LIST)(curList->Descriptors + curList->Count);
            ++i;
        }
    }

    //
    // Note the post filtered list count in the ResourceRequirementsList.
    //
    ResourceRequirementsList->AlternativeLists = listCount;

    DD(NULL,DDT,"Leave PptPnpFilterRemoveIrqResourceLists() - AlternativeLists= %d\n", listCount);

    return;
}

PVOID
PptPnpFilterGetEndOfResourceRequirementsList(
    IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirementsList
    )
/*++dvdf8

Routine Description:

    This function is a helper function called by PptPnpFilterRemoveIrqResourceLists()

    This function finds the end of an IO_RESOURCE_REQUIREMENTS_LIST 
      (list of IO_RESOURCE_LISTs).

Arguments:

    ResourceRequirementsList - The list to scan.

Return Value:

    Pointer to the next address past the end of the IO_RESOURCE_REQUIREMENTS_LIST.

--*/
{
    ULONG listCount = ResourceRequirementsList->AlternativeLists;
    PIO_RESOURCE_LIST curList;
    ULONG i;

    i=0;
    curList = ResourceRequirementsList->List;
    while( i < listCount ) {
        //
        // Pointer arithmetic based on the size of an IO_RESOURCE_DESCRIPTOR.
        //
        curList = (PIO_RESOURCE_LIST)(curList->Descriptors + curList->Count);
        ++i;
    }
    return (PVOID)curList;
}

VOID
PptPnpFilterNukeIrqResourceDescriptorsFromAllLists(
    PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirementsList
    )
/*++dvdf8

Routine Description:

    This function is a helper function called by 
      PptPnpFilterResourceRequirements(). 

    This function "nukes" all IRQ resources descriptors
      in the IO_RESOURCE_REQUIREMENTS_LIST by changing the descriptor
      types from CmResourceTypeInterrupt to CmResourceTypeNull.

Arguments:

    ResourceRequirementsList - The list to process.

Return Value:

    none.

--*/
{
    ULONG             listCount = ResourceRequirementsList->AlternativeLists;
    ULONG             i         = 0;
    PIO_RESOURCE_LIST curList   = ResourceRequirementsList->List;

    DD(NULL,DDT,"Enter PptPnpFilterNukeIrqResourceDescriptorsFromAllLists() - AlternativeLists= %d\n", listCount);

    //
    // Walk through the list of IO_RESOURCE_LISTs in the IO_RESOURCE_REQUIREMENTS list.
    //
    while( i < listCount ) {
        DD(NULL,DDT,"Nuking IRQs from List i=%d, curList= %x\n", i,curList);
        //
        // Nuke all IRQ resources from the current IO_RESOURCE_LIST.
        //
        PptPnpFilterNukeIrqResourceDescriptors( curList );
        curList = (PIO_RESOURCE_LIST)(curList->Descriptors + curList->Count);
        ++i;
    }
}

VOID
PptPnpFilterNukeIrqResourceDescriptors(
    PIO_RESOURCE_LIST IoResourceList
    )
/*++dvdf8

Routine Description:

    This function is a helper function called by 
      PptPnpFilterNukeIrqResourceDescriptorsFromAllLists().

    This function "nukes" all IRQ resources descriptors
      in the IO_RESOURCE_LIST by changing the descriptor
      types from CmResourceTypeInterrupt to CmResourceTypeNull.

Arguments:

    IoResourceList - The list to process.

Return Value:

    none.

--*/
{
    PIO_RESOURCE_DESCRIPTOR  pIoResourceDescriptorIn  = IoResourceList->Descriptors;
    ULONG                    i;

    //
    // Scan the descriptor list for Interrupt descriptors.
    //
    for (i = 0; i < IoResourceList->Count; ++i) {

        if (pIoResourceDescriptorIn->Type == CmResourceTypeInterrupt) {
            //
            // Found one - change resource type from Interrupt to Null.
            //
            pIoResourceDescriptorIn->Type = CmResourceTypeNull;
            DD(NULL,DDT," - giving up IRQ resource - MinimumVector: %d MaximumVector: %d\n",
                       pIoResourceDescriptorIn->u.Interrupt.MinimumVector,
                       pIoResourceDescriptorIn->u.Interrupt.MaximumVector);
        }
        ++pIoResourceDescriptorIn;
    }
}

BOOLEAN
PptPnpListContainsIrqResourceDescriptor(
    IN PIO_RESOURCE_LIST List
)
{
    ULONG i;
    PIO_RESOURCE_DESCRIPTOR curDesc = List->Descriptors;

    for(i=0; i<List->Count; ++i) {
        if(curDesc->Type == CmResourceTypeInterrupt) {
            return TRUE;
        } else {
            ++curDesc;
        }
    }
    return FALSE;
}

NTSTATUS
PptPnpBounceAndCatchPnpIrp(
    PFDO_EXTENSION Fdx,
    PIRP              Irp
)
/*++

  Pass a PnP IRP down the stack to our parent and catch it on the way back
    up after it has been handled by the drivers below us in the driver stack.

--*/
{
    NTSTATUS       status;
    KEVENT         event;
    PDEVICE_OBJECT parentDevObj = Fdx->ParentDeviceObject;

    DD((PCE)Fdx,DDT,"PptBounceAndCatchPnpIrp()\n");

    // setup
    KeInitializeEvent(&event, NotificationEvent, FALSE);
    IoCopyCurrentIrpStackLocationToNext(Irp);
    IoSetCompletionRoutine(Irp, PptSynchCompletionRoutine, &event, TRUE, TRUE, TRUE);

    // send
    status = IoCallDriver(parentDevObj, Irp);

    // wait for completion routine to signal that it has caught the IRP on
    //   its way back out
    KeWaitForSingleObject(&event, Suspended, KernelMode, FALSE, NULL);

    if (status == STATUS_PENDING) {
        // If IoCallDriver returned STATUS_PENDING, then we must
        //   extract the "real" status from the IRP
        status = Irp->IoStatus.Status;
    }

    return status;
}

NTSTATUS
PptPnpPassThroughPnpIrpAndReleaseRemoveLock(
    IN PFDO_EXTENSION Fdx,
    IN PIRP              Irp
)
/*++

  Pass a PnP IRP down the stack to our parent, 
    release RemoveLock, and return status from IoCallDriver.

--*/
{
    NTSTATUS status;

    IoSkipCurrentIrpStackLocation(Irp);
    status = IoCallDriver(Fdx->ParentDeviceObject, Irp);
    PptReleaseRemoveLock(&Fdx->RemoveLock, Irp);
    return status;
}


VOID
P4DestroyPdo(
    IN PDEVICE_OBJECT  Pdo
    )
{
    PPDO_EXTENSION  pdx = Pdo->DeviceExtension;
    PDEVICE_OBJECT  fdo = pdx->Fdo;
    PFDO_EXTENSION  fdx = fdo->DeviceExtension;

    DD((PCE)pdx,DDT,"P4DestroyPdo\n");

    //
    // Remove registry entry under HKLM\HARDWARE\DEVICEMAP\PARALLEL PORTS
    //
    if( pdx->PdoName ) {
        NTSTATUS status = RtlDeleteRegistryValue( RTL_REGISTRY_DEVICEMAP, (PWSTR)L"PARALLEL PORTS", pdx->PdoName );
        if( status != STATUS_SUCCESS ) {
            DD((PCE)pdx,DDW,"P4DestroyPdo - Failed to Delete DEVICEMAP registry entry - status=%x\n",status);
        }
    }

    //
    // remove self from FDO's DevDeletionListHead list
    //
    if( !IsListEmpty( &fdx->DevDeletionListHead ) ) {

        BOOLEAN      done  = FALSE;
        PLIST_ENTRY  first = NULL;
        
        while( !done ) {
            
            // look for self on list - remove if found

            PLIST_ENTRY current = RemoveHeadList( &fdx->DevDeletionListHead );        

            if( CONTAINING_RECORD( current, PDO_EXTENSION, DevDeletionList ) != pdx ) {

                // this is not the entry that we are looking for

                if( !first ) {

                    // note the first entry so we can stop if we search the entire list and don't find self

                    first = current;
                    InsertTailList( &fdx->DevDeletionListHead, current );

                } else {

                    // have we searched the entire list?

                    if( first == current ) {

                        // we searched the entire list and didn't find self - we must not be on the list
                        // put entry back on front of list, then we're done with search
                        DD((PCE)pdx,DDT,"P4DestroyPdo - searched entire list - we're not on it - done with search\n");
                        InsertHeadList( &fdx->DevDeletionListHead, current );
                        done = TRUE;

                    } else {

                        // not the entry that we're looking for - place at end of list - continue search
                        InsertTailList( &fdx->DevDeletionListHead, current );
                    }
                }

            } else {

                // found self - self removed from list - done with search
                DD((PCE)pdx,DDT,"P4DestroyPdo - found self on FDO's DevDeletionListHead and removed self - done with search\n");
                done = TRUE;
            }

        } // end while( !done )

    } // endif( !IsListEmpty... )


    //
    // clean up any ShadowBuffer queue used by hardware ECP modes
    //
    if( pdx->bShadowBuffer ) {
        BOOLEAN queueDeleted = Queue_Delete( &(pdx->ShadowBuffer) );
        if( !queueDeleted ) {
            PptAssertMsg( "Failed to delete queue?!?", FALSE );
        }
        pdx->bShadowBuffer = FALSE;
    }
    PptAssert( NULL == pdx->ShadowBuffer.theArray );


    //
    // clean up symbolic link - unless it has been previously cleaned up elsewhere
    //
    if( pdx->SymLinkName ) {
        P5DeletePdoSymLink( Pdo );
    }

    //
    // clean up other device extension pool allocations
    //
    if( pdx->Mfg ) {
        DD((PCE)pdx,DDT,"P4DestroyPdo - clean up Mfg <%s>\n", pdx->Mfg);
        ExFreePool( pdx->Mfg );
        pdx->Mfg = NULL;
    }
    if( pdx->Mdl ) {
        DD((PCE)pdx,DDT,"P4DestroyPdo - clean up Mdl <%s>\n", pdx->Mdl);
        ExFreePool( pdx->Mdl );
        pdx->Mdl = NULL;
    }
    if( pdx->Cid ) {
        DD((PCE)pdx,DDT,"P4DestroyPdo - clean up Cid <%s>\n", pdx->Cid);
        ExFreePool( pdx->Cid );
        pdx->Cid = NULL;
    }
    if( pdx->DeviceInterface.Buffer ) {
        DD((PCE)pdx,DDT,"P4DestroyPdo - clean up DeviceInterface <%S>\n", pdx->PdoName);
        RtlFreeUnicodeString( &pdx->DeviceInterface );
        pdx->DeviceInterfaceState = FALSE;
    }
    if( pdx->PdoName ) {
        DD((PCE)pdx,DDT,"P4DestroyPdo - clean up PdoName <%S>\n", pdx->PdoName);
        ExFreePool( pdx->PdoName );
        pdx->PdoName = NULL;
    }
    if( pdx->Location ) {
        DD((PCE)pdx,DDT,"P4DestroyPdo - clean up Location <%s>\n", pdx->Location);
        ExFreePool( pdx->Location );
        pdx->Location = NULL;
    }

    //
    // delete device object
    //
    IoDeleteDevice( Pdo );
}


VOID
P4SanitizeId(
    IN OUT PWSTR DeviceId
    )
/*++

Routine Description:

    This routine parses the UNICODE_NULL terminated string and replaces any invalid
    characters with an underscore character.

    Invalid characters are:
        c <= 0x20 (L' ')
        c >  0x7F
        c == 0x2C (L',')

Arguments:

    DeviceId - specifies a device id string (or part of one), must be
               UNICODE_NULL terminated.

Return Value:

    None.

--*/

{
    PWCHAR p;
    for( p = DeviceId; *p; ++p ) {
        if( (*p <= L' ') || (*p > (WCHAR)0x7F) || (*p == L',') ) {
            *p = L'_';
        }
    }
}


NTSTATUS
P4InitializePdo(
    IN PDEVICE_OBJECT  Fdo,
    IN PDEVICE_OBJECT  Pdo,
    IN enum _PdoType   PdoType,
    IN UCHAR           DaisyChainId, // Ignored unless PdoTypeDaisyChain == PdoType
    IN PCHAR           Ieee1284Id,   // NULL if none
    IN PWSTR           PdoName,
    IN PWSTR           SymLinkName
    )
{
    PFDO_EXTENSION   fdx = Fdo->DeviceExtension;
    PPDO_EXTENSION   pdx = Pdo->DeviceExtension;
    
    // we do buffered IO rather than direct IO
    Pdo->Flags |= DO_BUFFERED_IO;

    // DO_POWER_PAGABLE should be set same as parent FDO
    Pdo->Flags |= ( Fdo->Flags & DO_POWER_PAGABLE );

    // need to be able to forward Irps to parent
    Pdo->StackSize = Fdo->StackSize + 1;

    RtlZeroMemory( pdx, sizeof(PDO_EXTENSION) );

    // used by debugger extension
    pdx->Signature1 = PARPORT_TAG;
    pdx->Signature2 = PARPORT_TAG;

    // frequently need to know what type of PDO we have in order to do special case handling 
    pdx->PdoType = PdoType;

    // Save name used in call to IoCreateDevice (for debugging use)
    pdx->PdoName     = PdoName;

    // Save name used in call to IoCreateUnprotectedSymbolicLink for later call to IoDeleteSymbolicLink
    pdx->SymLinkName = SymLinkName;

    // initialize Mfg, Mdl, and Cid
    if( Ieee1284Id ) {
        //
        // Extract Mfg, Mdl, and Cid from Ieee1284Id and save in extension
        //

        // ParPnpFindDeviceIdKeys modifies deviceID passed in so make
        // a copy of the 1284 ID and pass in a pointer to the copy
        PCHAR tmpBuffer;
        ULONG tmpBufLen = strlen(Ieee1284Id) + sizeof(CHAR);

        DD((PCE)fdx,DDT,"P4InitializePdo - have Ieee1284Id\n");

        tmpBuffer = ExAllocatePool( PagedPool, tmpBufLen );
        if( tmpBuffer ) {
            PCHAR  mfg, mdl, cls, des, aid, cid;
            RtlZeroMemory( tmpBuffer, tmpBufLen );
            strcpy( tmpBuffer, Ieee1284Id );
            DD((PCE)fdx,DDT,"P4InitializePdo - calling ParPnpFindDeviceIdKeys\n");
            ParPnpFindDeviceIdKeys( &mfg, &mdl, &cls, &des, &aid, &cid, tmpBuffer );
            if( mfg ) {
                PCHAR buffer;
                ULONG bufLen = strlen(mfg) + sizeof(CHAR);
                DD((PCE)fdx,DDT,"P4InitializePdo - found mfg - <%s>\n",mfg);
                buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, bufLen );
                if( buffer ) {
                    RtlZeroMemory( buffer, bufLen );
                    strcpy( buffer, mfg );
                    pdx->Mfg = buffer;
                }
            }
            if( mdl ) {
                PCHAR buffer;
                ULONG bufLen = strlen(mdl) + sizeof(CHAR);
                DD((PCE)fdx,DDT,"P4InitializePdo - found mdl - <%s>\n",mdl);
                buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, bufLen );
                if( buffer ) {
                    RtlZeroMemory( buffer, bufLen );
                    strcpy( buffer, mdl );
                    pdx->Mdl = buffer;
                }
            }
            if( cid ) {
                PCHAR buffer;
                ULONG bufLen = strlen(cid) + sizeof(CHAR);
                DD((PCE)fdx,DDT,"P4InitializePdo - found cid - <%s>\n",cid);
                buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, bufLen );
                if( buffer ) {
                    RtlZeroMemory( buffer, bufLen );
                    strcpy( buffer, cid );
                    pdx->Cid = buffer;
                }
            } else {
                DD((PCE)fdx,DDT,"P4InitializePdo - no cid found\n");
            }
            ExFreePool( tmpBuffer );
        } else {
            DD((PCE)fdx,DDT,"P4InitializePdo - out of pool\n");
        }

    } else {
        //
        // PdoType doesn't have a Mfg, Mdl, or Cid, make up Mfg and Mdl, no Cid
        //
        const CHAR rawPortMfg[]   = "Microsoft";
        const CHAR rawPortMdl[]   = "RawPort";
        const CHAR legacyZipMfg[] = "IMG";
        const CHAR legacyZipMdl[] = "VP0";
        PCHAR      mfgStr;
        ULONG      mfgLen;
        PCHAR      mdlStr;
        ULONG      mdlLen;
        PCHAR      buffer;

        if( PdoTypeRawPort == PdoType ) {
            mfgStr = (PCHAR)rawPortMfg;
            mfgLen = sizeof(rawPortMfg);
            mdlStr = (PCHAR)rawPortMdl;
            mdlLen = sizeof(rawPortMdl);
        } else {
            // PdoTypeLegacyZip
            PptAssert( PdoTypeLegacyZip == PdoType );
            mfgStr = (PCHAR)legacyZipMfg;
            mfgLen = sizeof(legacyZipMfg);
            mdlStr = (PCHAR)legacyZipMdl;
            mdlLen = sizeof(legacyZipMdl);
        }
        buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, mfgLen );
        if( buffer ) {
            RtlZeroMemory( buffer, mfgLen );
            strcpy( buffer, mfgStr );
            pdx->Mfg = buffer;
        }
        buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, mdlLen );
        if( buffer ) {
            RtlZeroMemory( buffer, mdlLen );
            strcpy( buffer, mdlStr );
            pdx->Mdl = buffer;
        }
        pdx->Cid = NULL;
    }

    // initialize Location information - LPTx or LPTx.y
    PptAssert( fdx->PnpInfo.PortName &&
               ( (0 == wcscmp(fdx->PnpInfo.PortName, L"LPT1") ) ||
                 (0 == wcscmp(fdx->PnpInfo.PortName, L"LPT2") ) ||
                 (0 == wcscmp(fdx->PnpInfo.PortName, L"LPT3") ) ) );

    switch( PdoType ) {
        PCHAR buffer;
        ULONG bufLen;

    case PdoTypeRawPort :
        bufLen = sizeof("LPTx");
        buffer = ExAllocatePool( NonPagedPool, bufLen );
        if( buffer ) {
            RtlZeroMemory( buffer, bufLen );
            _snprintf( buffer, bufLen, "%S", fdx->PnpInfo.PortName );
            pdx->Location = buffer;
        } else {
            DD((PCE)fdx,DDT,"P4InitializePdo - out of pool");
        }
        break;

    case PdoTypeDaisyChain :
        bufLen = sizeof("LPTx.y");
        buffer = ExAllocatePool( NonPagedPool, bufLen );
        if( buffer ) {
            PptAssert( DaisyChainId >= 0 && DaisyChainId < 4 );
            RtlZeroMemory( buffer, bufLen );
            _snprintf( buffer, bufLen, "%S.%1d", fdx->PnpInfo.PortName, DaisyChainId );
            pdx->Location = buffer;
        } else {
            DD((PCE)fdx,DDT,"P4InitializePdo - out of pool");
        }
        break;

    case PdoTypeEndOfChain :
        bufLen = sizeof("LPTx.y");
        buffer = ExAllocatePool( NonPagedPool, bufLen );
        if( buffer ) {
            RtlZeroMemory( buffer, bufLen );
            _snprintf( buffer, bufLen, "%S.4", fdx->PnpInfo.PortName );
            pdx->Location = buffer;
        } else {
            DD((PCE)fdx,DDT,"P4InitializePdo - out of pool");
        }
        break;

    case PdoTypeLegacyZip :
        bufLen = sizeof("LPTx.y");
        buffer = ExAllocatePool( NonPagedPool, bufLen );
        if( buffer ) {
            RtlZeroMemory( buffer, bufLen );
            _snprintf( buffer, bufLen, "%S.5", fdx->PnpInfo.PortName );
            pdx->Location = buffer;
        } else {
            DD((PCE)fdx,DDT,"P4InitializePdo - out of pool");
        }
        break;

    default :
        PptAssert(!"Invalid PdoType");
    }


    // initialize synchronization and list mechanisms
    ExInitializeFastMutex( &pdx->OpenCloseMutex );
    InitializeListHead( &pdx->WorkQueue );
    KeInitializeSemaphore( &pdx->RequestSemaphore, 0, MAXLONG );
    KeInitializeEvent( &pdx->PauseEvent, NotificationEvent, TRUE );


    // general info
    pdx->DeviceObject         = Pdo;
    pdx->DevType              = DevTypePdo;

    pdx->EndOfChain           = (PdoTypeEndOfChain == PdoType) ? TRUE : FALSE; // override later if this is a
    pdx->Ieee1284_3DeviceId   = (PdoTypeDaisyChain == PdoType) ? DaisyChainId : 0; //   1284.3 Daisy Chain device

    pdx->IsPdo                = TRUE;       // really means !FDO
    pdx->Fdo                  = Fdo;
    pdx->ParClassFdo          = Fdo;        // depricated - use Fdo field on prev line
    pdx->PortDeviceObject     = Fdo;        // depricated - use Fdo field 2 lines up - modify functions to use it
    pdx->BusyDelay            = 0;
    pdx->BusyDelayDetermined  = FALSE;
    
    // timing constants
    pdx->TimerStart                  = PAR_WRITE_TIMEOUT_VALUE;
    pdx->AbsoluteOneSecond.QuadPart  = 10*1000*1000;
    pdx->IdleTimeout.QuadPart        = - 250*10*1000;       // 250 ms
    pdx->OneSecond.QuadPart          = - pdx->AbsoluteOneSecond.QuadPart;

    // init IEEE 1284 protocol settings
    ParInitializeExtension1284Info( pdx );

    pdx->DeviceType = PAR_DEVTYPE_PDO; // deprecated - use DevType in common extension

    if( Ieee1284Id ) {
        ULONG length = strlen(Ieee1284Id) + 1;
        PCHAR copyOfIeee1284Id = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, length );
        if( copyOfIeee1284Id ) {
            RtlZeroMemory( copyOfIeee1284Id, length );
            strcpy( copyOfIeee1284Id, Ieee1284Id );
            ParDetectDot3DataLink( pdx, Ieee1284Id );
            ExFreePool( copyOfIeee1284Id );
        }
    }

    // RMT - doug - need to put this back in - ParCheckParameters(DevObj->DeviceExtension);   // Check the registry for parameter overrides

    // Write symbolic link map info to the registry.
    {
        NTSTATUS status = RtlWriteRegistryValue( RTL_REGISTRY_DEVICEMAP,
                                                 (PWSTR)L"PARALLEL PORTS",
                                                 pdx->PdoName,
                                                 REG_SZ,
                                                 pdx->SymLinkName,
                                                 wcslen(pdx->SymLinkName)*sizeof(WCHAR) + sizeof(WCHAR) );
        if( NT_SUCCESS( status ) ) {
            DD((PCE)fdx,DDT,"Created DEVICEMAP registry entry - %S -> %S\n",pdx->PdoName,pdx->SymLinkName);
        } else {
            DD((PCE)fdx,DDT,"Failed to create DEVICEMAP registry entry - status = %x\n", status);
        }
    }

    Pdo->Flags &= ~DO_DEVICE_INITIALIZING;      // Tell the IO system that we are ready to receive IRPs
    return STATUS_SUCCESS;
}


PWSTR
P4MakePdoSymLinkName(
    IN PWSTR          LptName,
    IN enum _PdoType  PdoType,
    IN UCHAR          DaisyChainId, // ignored unless PdoType == PdoTypeDaisyChain
    IN UCHAR          RetryNumber
    )
/*

    Generate \DosDevices\LPTx or \DosDevices\LPTx.y PdoSymbolicLinkName from LPTx Name

    In:  LPTx
    Out: \DosDevices\LPTx or \DosDevices\LPTx.y depending on PdoType

    examples: 
    
      LPT1 PdoTypeEndOfChain                  -> \DosDevices\LPT1.4
      LPT2 PdoTypeDaisyChain DaisyChainId==3  -> \DosDevices\LPT2.3
      LPT3 PdoTypeRawPort                     -> \DosDevices\LPT3
    
    returns - pointer to pool allocation containing PdoSymbolicLinkName on success (caller frees), or
            - NULL on error 
    
*/
{
    const UCHAR  maxDaisyChainSuffix = 3;
    const UCHAR  endOfChainSuffix    = 4;
    const UCHAR  legacyZipSuffix     = 5;
    const ULONG  maxSymLinkNameLength = sizeof(L"\\DosDevices\\LPTx.y-z");
    
    UCHAR        suffix = 0;
    PWSTR        buffer;

    if( !LptName ) {
        PptAssert( !"NULL LptName" );
        return NULL;
    }

    DD(NULL,DDT,"P4MakePdoSymLinkName - LptName = %S\n",LptName);

    switch( PdoType ) {
    case PdoTypeDaisyChain :
        if( DaisyChainId > maxDaisyChainSuffix ) {
            PptAssert( !"DaisyChainId > maxDaisyChainSuffix" );
            return NULL;
        }
        suffix = DaisyChainId;
        break;
    case PdoTypeEndOfChain :
        suffix = endOfChainSuffix;
        break;
    case PdoTypeLegacyZip :
        suffix = legacyZipSuffix;
        break;
    case PdoTypeRawPort :
        break; // no suffix
    default :
        PptAssert( !"Unrecognised PdoType" );
        return NULL;
    }

    if( 0 == RetryNumber ) {
        buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, maxSymLinkNameLength );
        if( buffer ) {
            RtlZeroMemory( buffer, maxSymLinkNameLength );
            if( PdoTypeRawPort == PdoType ) {
                swprintf( buffer, L"\\DosDevices\\%s\0", LptName );
            } else {
                swprintf( buffer, L"\\DosDevices\\%s.%d\0", LptName, suffix );
            }
        }
    } else if( RetryNumber <= 9 ) {
        buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, maxSymLinkNameLength );
        if( buffer ) {
            RtlZeroMemory( buffer, maxSymLinkNameLength );
            if( PdoTypeRawPort == PdoType ) {
                swprintf( buffer, L"\\DosDevices\\%s-%1d\0", LptName, RetryNumber );
            } else {
                swprintf( buffer, L"\\DosDevices\\%s.%d-%1d\0", LptName, suffix, RetryNumber );
            }
        }
    } else {
        buffer = NULL;
    }

    return buffer;
}


PWSTR
P4MakePdoDeviceName(
    IN PWSTR          LptName,
    IN enum _PdoType  PdoType,
    IN UCHAR          DaisyChainId, // ignored unless PdoType == PdoTypeDaisyChain
    IN UCHAR          RetryNumber   // used if we had a name collision on IoCreateDevice
    )
/*

    Generate \Device\Parallely or \Device\Parallely.z PDO DeviceName from LPTx Name

    In:  LPTx
    Out: \Device\Parallely or \Device\Parallely.z depending on PdoType

    y == (x-1), optional .z suffix is based on type of Pdo
    
    examples: 
    
      LPT1 PdoTypeEndOfChain                  -> \Device\Parallel0.4
      LPT2 PdoTypeDaisyChain DaisyChainId==3  -> \Device\Parallel1.3
      LPT3 PdoTypeRawPort                     -> \Device\Parallel2
    
    returns - pointer to pool allocation containing PdoDeviceName on success (caller frees), or
            - NULL on error 
    
*/
{
    const UCHAR  maxDaisyChainSuffix = 3;
    const UCHAR  endOfChainSuffix    = 4;
    const UCHAR  legacyZipSuffix     = 5;
    ULONG        maxDeviceNameLength;

    UCHAR  lptNumber;
    UCHAR  suffix = 0;
    PWSTR  buffer = NULL;

    DD(NULL,DDT,"P4MakePdoDeviceName - LptName=<%S>, PdoType=%d, DaisyChainId=%d\n",LptName,PdoType,DaisyChainId);  


    if( !LptName ) {
        PptAssert( !"NULL LptName" );
        return NULL;
    }

    switch( PdoType ) {
    case PdoTypeDaisyChain :
        if( DaisyChainId > maxDaisyChainSuffix ) {
            PptAssert( !"DaisyChainId > maxDaisyChainSuffix" );
            return NULL;
        }
        suffix = DaisyChainId;
        break;
    case PdoTypeEndOfChain :
        suffix = endOfChainSuffix;
        break;
    case PdoTypeLegacyZip :
        suffix = legacyZipSuffix;
        break;
    case PdoTypeRawPort :
        break; // no suffix
    default :
        PptAssert( !"Unrecognised PdoType" );
        return NULL;
    }

    if     ( 0 == wcscmp( (PCWSTR)L"LPT1", LptName ) ) { lptNumber = 1; } 
    else if( 0 == wcscmp( (PCWSTR)L"LPT2", LptName ) ) { lptNumber = 2; }
    else if( 0 == wcscmp( (PCWSTR)L"LPT3", LptName ) ) { lptNumber = 3; }
    else {
        PptAssert( !"LptName not of the form LPTx where 1 <= x <= 3" );
        return NULL;
    }

    DD(NULL,DDT,"P4MakePdoDeviceName - suffix=%d\n",suffix);

    if( 0 == RetryNumber ) {
        maxDeviceNameLength = sizeof(L"\\Device\\Parallelx.y");
        buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, maxDeviceNameLength );
        if( buffer ) {
            RtlZeroMemory( buffer, maxDeviceNameLength );
            if( PdoTypeRawPort == PdoType ) {
                swprintf( buffer, L"\\Device\\Parallel%d\0", lptNumber-1 );
            } else {
                swprintf( buffer, L"\\Device\\Parallel%d.%d\0", lptNumber-1, suffix );
            }
        }
    } else {
        if( RetryNumber <= 9 ) {
            maxDeviceNameLength = sizeof(L"\\Device\\Parallelx.y-z");
            buffer = ExAllocatePool( PagedPool | POOL_COLD_ALLOCATION, maxDeviceNameLength );
            if( buffer ) {
                RtlZeroMemory( buffer, maxDeviceNameLength );
                if( PdoTypeRawPort == PdoType ) {
                    swprintf( buffer, L"\\Device\\Parallel%d-%1d\0", lptNumber-1, RetryNumber );
                } else {
                    swprintf( buffer, L"\\Device\\Parallel%d.%d-%1d\0", lptNumber-1, suffix, RetryNumber );
                }
            }
        }
    }

    if( buffer ) {
        DD(NULL,DDT,"P4MakePdoDeviceName <%S>\n",buffer);
    }

    return buffer;
}


PDEVICE_OBJECT
P4CreatePdo(
    IN PDEVICE_OBJECT  Fdo,
    IN enum _PdoType   PdoType,
    IN UCHAR           DaisyChainId, // ignored unless PdoType == PdoTypeDaisyChain
    IN PCHAR           Ieee1284Id    // NULL if device does not report IEEE 1284 Device ID
    )
{
    PFDO_EXTENSION  fdx             = Fdo->DeviceExtension;
    PWSTR           lptName         = fdx->PnpInfo.PortName;
    NTSTATUS        status          = STATUS_UNSUCCESSFUL;
    PDEVICE_OBJECT  pdo             = NULL;
    PWSTR           wstrDeviceName  = NULL;
    PWSTR           wstrSymLinkName = NULL;
    BOOLEAN         createdSymLink  = FALSE;
    UCHAR           retryNumber     = 0;

    UNICODE_STRING  deviceName;
    UNICODE_STRING  symLinkName;

    DD((PCE)fdx,DDT,"P4CreatePdo - enter - PdoType= %d, DaisyChainId=%d, Ieee1284Id=<%s>\n", PdoType, DaisyChainId, Ieee1284Id);

    __try {

        if( !lptName ) {
            DD((PCE)fdx,DDT,"P4CreatePdo - no lptName\n");
            __leave;
        }

        DD((PCE)fdx,DDT,"P4CreatePdo - lptName = %S\n",lptName);
        
targetRetryDeviceName:

        wstrDeviceName = P4MakePdoDeviceName( lptName, PdoType, DaisyChainId, retryNumber );
        if( !wstrDeviceName ) {
            DD((PCE)fdx,DDT,"P4MakePdoDeviceName FAILED\n");
            __leave;
        }

        DD((PCE)fdx,DDT,"P4CreatePdo - wstrDeviceName = %S\n",wstrDeviceName);
        RtlInitUnicodeString( &deviceName, wstrDeviceName );

        status = IoCreateDevice( fdx->DriverObject, 
                                 sizeof(PDO_EXTENSION),
                                 &deviceName,
                                 FILE_DEVICE_PARALLEL_PORT,
                                 FILE_DEVICE_SECURE_OPEN,
                                 TRUE,
                                 &pdo );
        
        if( STATUS_SUCCESS != status ) {
            DD((PCE)fdx,DDT,"P4CreatePdo - FAILED\n");
            pdo = NULL; // just to make sure that we don't try to use this later
            if( STATUS_OBJECT_NAME_COLLISION == status ) {
                // try again with another name
                DD(NULL,DDE,"P4CreatePdo - STATUS_OBJECT_NAME_COLLISION on %S\n",wstrDeviceName);
                ExFreePool( wstrDeviceName );
                ++retryNumber;
                goto targetRetryDeviceName;
            }
            __leave;
        }

        retryNumber = 0;

targetRetrySymLink:

        wstrSymLinkName = P4MakePdoSymLinkName( lptName, PdoType, DaisyChainId, retryNumber );
        if( !wstrSymLinkName ) {
            DD((PCE)fdx,DDT,"P4MakePdoSymLinkName FAILED\n");
            __leave;
        }
        RtlInitUnicodeString( &symLinkName, wstrSymLinkName );

        status = IoCreateUnprotectedSymbolicLink( &symLinkName , &deviceName );
        if( STATUS_SUCCESS != status ) {
            if( STATUS_OBJECT_NAME_COLLISION == status ) {
                DD(NULL,DDE,"P4CreatePdo - STATUS_OBJECT_NAME_COLLISION on %S\n", wstrSymLinkName);
                ExFreePool( wstrSymLinkName );
                ++retryNumber;
                goto targetRetrySymLink;
            }
            DD((PCE)fdx,DDT,"P4CreatePdo - create SymLink FAILED\n");
            __leave;
        } else {
            createdSymLink = TRUE;
        }

        if( (NULL == Ieee1284Id) && (PdoTypeDaisyChain == PdoType) ) {
            // SCM Micro device?
            PPDO_EXTENSION              pdx = pdo->DeviceExtension;
            PPARALLEL_PORT_INFORMATION  PortInfo = &fdx->PortInfo;
            BOOLEAN                     bBuildStlDeviceId;
            ULONG                       DeviceIdSize;

            pdx->Controller =  PortInfo->Controller;

            bBuildStlDeviceId = ParStlCheckIfStl( pdx, DaisyChainId ) ;

            if( TRUE == bBuildStlDeviceId ) {
                Ieee1284Id = ParStlQueryStlDeviceId( pdx, NULL, 0, &DeviceIdSize, FALSE );
            }

            pdx->OriginalController = PortInfo->OriginalController;

            P4InitializePdo( Fdo, pdo, PdoType, DaisyChainId, Ieee1284Id, wstrDeviceName, wstrSymLinkName );
            
            if (Ieee1284Id) {
                 ExFreePool (Ieee1284Id);
                 Ieee1284Id = NULL;
            }

        } else {
            P4InitializePdo( Fdo, pdo, PdoType, DaisyChainId, Ieee1284Id, wstrDeviceName, wstrSymLinkName );
        }

    } // __try

    __finally {
        if( STATUS_SUCCESS != status ) {
            // failure - do cleanup
            if( createdSymLink ) {
                IoDeleteSymbolicLink( &symLinkName );
            }
            if( pdo ) {
                IoDeleteDevice( pdo );
                pdo = NULL;
            }
            if( wstrDeviceName ) {
                ExFreePool( wstrDeviceName );
            }
            if( wstrSymLinkName ) {
                ExFreePool( wstrSymLinkName );
            }
        }
    } // __finally

    return pdo;
}


VOID
P4SanitizeMultiSzId( 
    IN OUT  PWSTR  WCharBuffer,
    IN      ULONG  BufWCharCount
    )
    // BufWCharCount == number of WCHARs (not bytes) in the string
    //
    // Sanitize the MULTI_SZ (HardwareID or CompatibleID) for PnP:
    //   1) Leave UNICODE_NULLs (L'\0') alone, otherwise
    //   2) Convert illegal characters to underscores (L'_')
    //      illegal characters are ( == L',' ) || ( <= L' ' ) || ( > (WCHAR)0x7F )
{
    PWCHAR p = WCharBuffer;
    ULONG  i;
    for( i = 0; i < BufWCharCount ; ++i, ++p ) {
        if( L'\0'== *p ) {
            continue;
        } else if( (*p <= L' ') || (*p > (WCHAR)0x7F) || (L',' == *p) ) {
            *p = L'_';
        }
    }
}