windows-server-2003/drivers/wdm/usb/driver/wceusbsh/common.c

/*++

Copyright (c) 1999-2000 Microsoft Corporation

Module Name :

    common.c

Abstract:

    Common code for the Windows CE
    USB Serial Host and Filter drivers

Author:

    Jeff Midkiff (jeffmi)     08-24-99

--*/
#include <stdio.h>

#include "wceusbsh.h"

#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGEWCE0, QueryRegistryParameters)
#pragma alloc_text(PAGEWCE0, CreateDevObjAndSymLink)
#pragma alloc_text(PAGEWCE0, DeleteDevObjAndSymLink)
#pragma alloc_text(PAGEWCE0, IsWin9x)

#pragma alloc_text(PAGEWCE1, LogError)
#endif


NTSTATUS
QueryRegistryParameters(
   IN PUNICODE_STRING RegistryPath
    )
/*++

This routine queryies the Registry for our Parameters key.
We are given the RegistryPath to our driver during DriverEntry,
but don't yet have an extension, so we store the values in globals
until we get our device extension.

The values are setup from our INF.

On WinNT this is under
   HKLM\SYSTEM\ControlSet\Services\wceusbsh\Parameters

On Win98 this is under
   HKLM\System\CurrentControlSet\Services\Class\WCESUSB\000*


Returns - nothing; use defaults

--*/
{
    #define NUM_REG_ENTRIES 6
    RTL_QUERY_REGISTRY_TABLE rtlQueryRegTbl[ NUM_REG_ENTRIES + 1 ];

    ULONG sizeOfUl = sizeof( ULONG );
    ULONG ulAlternateSetting = DEFAULT_ALTERNATE_SETTING;
    LONG  lIntTimout = DEFAULT_INT_PIPE_TIMEOUT;
    ULONG ulMaxPipeErrors = DEFAULT_MAX_PIPE_DEVICE_ERRORS;
    ULONG ulDebugLevel = DBG_OFF;
    ULONG ulExposeComPort = FALSE;

    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();

    ASSERT( RegistryPath != NULL );

    RtlZeroMemory( rtlQueryRegTbl, sizeof(rtlQueryRegTbl) );

    //
    // Setup the query table
    // Note: the 1st table entry is the \Parameters subkey,
    // and the last table entry is NULL
    //
    rtlQueryRegTbl[0].QueryRoutine = NULL;
    rtlQueryRegTbl[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
    rtlQueryRegTbl[0].Name = L"Parameters";
    rtlQueryRegTbl[0].EntryContext = NULL;
    rtlQueryRegTbl[0].DefaultType = (ULONG_PTR)NULL;
    rtlQueryRegTbl[0].DefaultData = NULL;
    rtlQueryRegTbl[0].DefaultLength = (ULONG_PTR)NULL;

    rtlQueryRegTbl[1].QueryRoutine = NULL;
    rtlQueryRegTbl[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
    rtlQueryRegTbl[1].Name = L"DebugLevel";
    rtlQueryRegTbl[1].EntryContext = &DebugLevel;
    rtlQueryRegTbl[1].DefaultType = REG_DWORD;
    rtlQueryRegTbl[1].DefaultData = &ulDebugLevel;
    rtlQueryRegTbl[1].DefaultLength = sizeOfUl;

    rtlQueryRegTbl[2].QueryRoutine = NULL;
    rtlQueryRegTbl[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
    rtlQueryRegTbl[2].Name = L"AlternateSetting";
    rtlQueryRegTbl[2].EntryContext = &g_ulAlternateSetting;
    rtlQueryRegTbl[2].DefaultType = REG_DWORD;
    rtlQueryRegTbl[2].DefaultData = &ulAlternateSetting;
    rtlQueryRegTbl[2].DefaultLength = sizeOfUl;

    rtlQueryRegTbl[3].QueryRoutine = NULL;
    rtlQueryRegTbl[3].Flags = RTL_QUERY_REGISTRY_DIRECT;
    rtlQueryRegTbl[3].Name = L"InterruptTimeout";
    rtlQueryRegTbl[3].EntryContext = &g_lIntTimout;
    rtlQueryRegTbl[3].DefaultType = REG_DWORD;
    rtlQueryRegTbl[3].DefaultData = &lIntTimout;
    rtlQueryRegTbl[3].DefaultLength = sizeOfUl;

    rtlQueryRegTbl[4].QueryRoutine = NULL;
    rtlQueryRegTbl[4].Flags = RTL_QUERY_REGISTRY_DIRECT;
    rtlQueryRegTbl[4].Name = L"MaxPipeErrors";
    rtlQueryRegTbl[4].EntryContext = &g_ulMaxPipeErrors;
    rtlQueryRegTbl[4].DefaultType = REG_DWORD;
    rtlQueryRegTbl[4].DefaultData = &ulMaxPipeErrors;
    rtlQueryRegTbl[4].DefaultLength = sizeOfUl;

    rtlQueryRegTbl[5].QueryRoutine = NULL;
    rtlQueryRegTbl[5].Flags = RTL_QUERY_REGISTRY_DIRECT;
    rtlQueryRegTbl[5].Name = L"ExposeComPort";
    rtlQueryRegTbl[5].EntryContext = &g_ExposeComPort;
    rtlQueryRegTbl[5].DefaultType = REG_DWORD;
    rtlQueryRegTbl[5].DefaultData = &ulExposeComPort;
    rtlQueryRegTbl[5].DefaultLength = sizeOfUl;

    //
    // query the Registry
    //
    status = RtlQueryRegistryValues(
                RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,  // RelativeTo
                RegistryPath->Buffer,                           // Path
                rtlQueryRegTbl,                                 // QueryTable
                NULL,                                           // Context
                NULL );                                         // Environment

    if ( !NT_SUCCESS( status ) )  {
      //
      // if registry query failed then use defaults
      //
      DbgDump( DBG_INIT,  ("RtlQueryRegistryValues error: 0x%x\n", status) );

      g_ulAlternateSetting = ulAlternateSetting;
      g_lIntTimout = lIntTimout;
      g_ulMaxPipeErrors = ulMaxPipeErrors;
      DebugLevel = DBG_OFF;

    }

   DbgDump( DBG_INIT, ("DebugLevel = 0x%x\n", DebugLevel));

   DbgDump( DBG_INIT, ("AlternateSetting = %d\n", g_ulAlternateSetting));
   DbgDump( DBG_INIT, ("MaxPipeErrors = %d\n", g_ulMaxPipeErrors));
   DbgDump( DBG_INIT, ("INT Timeout = %d\n", g_lIntTimout));

   return status;
}


VOID
ReleaseSlot(
   IN LONG Slot
   )
{
   LONG lNumDevices = InterlockedDecrement(&g_NumDevices);
   UNREFERENCED_PARAMETER( Slot );

   ASSERT( lNumDevices >= 0);

   return;
}


NTSTATUS
AcquireSlot(
   OUT PULONG PSlot
   )
{
   NTSTATUS status = STATUS_SUCCESS;

   *PSlot = InterlockedIncrement(&g_NumDevices);

   if (*PSlot == (ULONG)0) {
      status = STATUS_INVALID_DEVICE_REQUEST;
   }

   return status;
}


NTSTATUS
CreateDevObjAndSymLink(
    IN PDRIVER_OBJECT PDrvObj,
    IN PDEVICE_OBJECT PPDO,
    IN PDEVICE_OBJECT *PpDevObj,
    IN PCHAR PDevName
    )
/*++

Routine Description:

    Creates a named device object and symbolic link
    for the next available device instance. Saves both the \\Device\\PDevName%n
    and \\DosDevices\\PDevName%n in the device extension.

    Also registers our device interface with PnP system.

Arguments:

    PDrvObj - Pointer to our driver object
    PPDO - Pointer to the PDO for the stack to which we should add ourselves
    PDevName - device name to use

Return Value:

    NTSTATUS

--*/
{
   PDEVICE_EXTENSION pDevExt = NULL;
   NTSTATUS status;
   ULONG deviceInstance;
   ULONG bufferLen;
   BOOLEAN gotSlot = FALSE;

   ANSI_STRING asDevName;
   ANSI_STRING asDosDevName;

   UNICODE_STRING usDeviceName = {0}; // seen only in kernel-mode namespace
   UNICODE_STRING usDosDevName = {0}; // seen in user-mode namespace

   CHAR dosDeviceNameBuffer[DOS_NAME_MAX];
   CHAR deviceNameBuffer[DOS_NAME_MAX];

   DbgDump(DBG_INIT, (">CreateDevObjAndSymLink\n"));
   PAGED_CODE();
   ASSERT( PPDO );

   //
   // init the callers device obj
   //
   *PpDevObj = NULL;

   //
   // Get the next device instance number
   //
   status = AcquireSlot(&deviceInstance);
   if (status != STATUS_SUCCESS) {
      DbgDump(DBG_ERR, ("AcquireSlot error: 0x%x\n", status));
      goto CreateDeviceObjectError;
   } else {
      gotSlot = TRUE;
   }

   //
   // concat device name & instance number
   //
   ASSERT( *PDevName != (CHAR)NULL);
   sprintf(dosDeviceNameBuffer, "%s%s%03d", "\\DosDevices\\", PDevName,
           deviceInstance);
   sprintf(deviceNameBuffer, "%s%s%03d", "\\Device\\", PDevName,
           deviceInstance);

   // convert names to ANSI string
   RtlInitAnsiString(&asDevName, deviceNameBuffer);
   RtlInitAnsiString(&asDosDevName, dosDeviceNameBuffer);

   usDeviceName.Length = 0;
   usDeviceName.Buffer = NULL;

   usDosDevName.Length = 0;
   usDosDevName.Buffer = NULL;

   //
   // convert names to UNICODE
   //
   status = RtlAnsiStringToUnicodeString(&usDeviceName, &asDevName, TRUE);
   if (status != STATUS_SUCCESS) {
      DbgDump(DBG_ERR, ("RtlAnsiStringToUnicodeString error: 0x%x\n", status));
      goto CreateDeviceObjectError;
   }

   status = RtlAnsiStringToUnicodeString(&usDosDevName, &asDosDevName, TRUE);
   if (status != STATUS_SUCCESS) {
      DbgDump(DBG_ERR, ("RtlAnsiStringToUnicodeString error: 0x%x\n", status));
      goto CreateDeviceObjectError;
   }

   //
   // create the named devive object
   // Note: we may want to change this to a non-exclusive later
   // so xena to come in without the filter.
   //
   status = IoCreateDevice( PDrvObj,
                            sizeof(DEVICE_EXTENSION),
                            &usDeviceName,
                            FILE_DEVICE_SERIAL_PORT,
                            0,
                            TRUE,       // Note: SerialPorts are exclusive
                            PpDevObj);

   if (status != STATUS_SUCCESS) {
      DbgDump(DBG_ERR, ("IoCreateDevice error: 0x%x\n", status));
      TEST_TRAP();
      goto CreateDeviceObjectError;
   }

   //
   // get pointer to device extension
   //
   pDevExt = (PDEVICE_EXTENSION) (*PpDevObj)->DeviceExtension;

   RtlZeroMemory(pDevExt, sizeof(DEVICE_EXTENSION)); // (redundant)

   //
   // init SERIAL_PORT_INTERFACE
   //
   pDevExt->SerialPort.Type = WCE_SERIAL_PORT_TYPE;

   //
   // create symbolic link
   //
   status = IoCreateUnprotectedSymbolicLink(&usDosDevName, &usDeviceName);
   if (status != STATUS_SUCCESS) {
      DbgDump(DBG_ERR, ("IoCreateUnprotectedSymbolicLink error: 0x%x\n", status));
      goto CreateDeviceObjectError;
   }

   DbgDump(DBG_INIT, ("SymbolicLink: %ws\n", usDosDevName.Buffer));

   //
   // Make the device visible via a device association as well.
   // The reference string is the eight digit device index
   //
   status = IoRegisterDeviceInterface(
                PPDO,
                (LPGUID)&GUID_WCE_SERIAL_USB,
                NULL,
                &pDevExt->DeviceClassSymbolicName );

   if (status != STATUS_SUCCESS) {
      DbgDump(DBG_ERR, ("IoRegisterDeviceInterface error: 0x%x\n", status));
      pDevExt->DeviceClassSymbolicName.Buffer = NULL;
      goto CreateDeviceObjectError;
   }

   DbgDump(DBG_INIT, ("DeviceClassSymbolicName: %ws\n", pDevExt->DeviceClassSymbolicName.Buffer));

   //
   // save the Dos Device link name in our extension
   //
   strcpy(pDevExt->DosDeviceName, dosDeviceNameBuffer);

   pDevExt->SymbolicLink = TRUE;


   //
   // save (kernel) device name in extension
   //
   bufferLen = RtlAnsiStringToUnicodeSize(&asDevName);

   pDevExt->DeviceName.Length = 0;
   pDevExt->DeviceName.MaximumLength = (USHORT)bufferLen;

   pDevExt->DeviceName.Buffer = ExAllocatePool(PagedPool, bufferLen);
   if (pDevExt->DeviceName.Buffer == NULL) {
      //
      // Skip out.  We have worse problems than missing
      // the name if we have no memory at this point.
      //
      status = STATUS_INSUFFICIENT_RESOURCES;
      DbgDump(DBG_ERR, ("CreateDevObjAndSymLink ERROR: 0x%x\n", status));
      goto CreateDeviceObjectError;
   }

   RtlAnsiStringToUnicodeString(&pDevExt->DeviceName, &asDevName, FALSE);
   // save 1's based device instance number
   pDevExt->SerialPort.Com.Instance = deviceInstance;

CreateDeviceObjectError:;

   //
   // free Unicode strings
   //
   RtlFreeUnicodeString(&usDeviceName);
   RtlFreeUnicodeString(&usDosDevName);

   //
   // Delete the devobj if there was an error
   //
   if (status != STATUS_SUCCESS) {

      if ( *PpDevObj ) {

         DeleteDevObjAndSymLink( *PpDevObj );

         *PpDevObj = NULL;

      }

      if (gotSlot) {
         ReleaseSlot(deviceInstance);
      }
   }

   DbgDump(DBG_INIT, ("<CreateDevObjAndSymLink 0x%x\n", status));

   return status;
}



NTSTATUS
DeleteDevObjAndSymLink(
   IN PDEVICE_OBJECT PDevObj
   )
{
   PDEVICE_EXTENSION pDevExt;
   UNICODE_STRING    usDevLink;
   ANSI_STRING       asDevLink;
   NTSTATUS          NtStatus = STATUS_SUCCESS;

   DbgDump(DBG_INIT, (">DeleteDevObjAndSymLink\n"));
   PAGED_CODE();
   ASSERT( PDevObj );

   pDevExt = (PDEVICE_EXTENSION) PDevObj->DeviceExtension;
   ASSERT( pDevExt );

   // get rid of the symbolic link
   if ( pDevExt->SymbolicLink ) {

      RtlInitAnsiString( &asDevLink, pDevExt->DosDeviceName );

      NtStatus = RtlAnsiStringToUnicodeString( &usDevLink,
                                              &asDevLink, TRUE);

      ASSERT(STATUS_SUCCESS == NtStatus);
      NtStatus = IoDeleteSymbolicLink(&usDevLink);

   }

    if (pDevExt->DeviceClassSymbolicName.Buffer)
    {
        NtStatus = IoSetDeviceInterfaceState(&pDevExt->DeviceClassSymbolicName, FALSE);
        if (NT_SUCCESS(NtStatus)) {
            DbgDump(DBG_WRN, ("IoSetDeviceInterfaceState.3: OFF\n"));
        }

        ExFreePool( pDevExt->DeviceClassSymbolicName.Buffer );
        pDevExt->DeviceClassSymbolicName.Buffer = NULL;
   }

   if (pDevExt->DeviceName.Buffer != NULL) {
      ExFreePool(pDevExt->DeviceName.Buffer);
      RtlInitUnicodeString(&pDevExt->DeviceName, NULL);
   }

   //
   // Wait to do this untill here as this triggers the unload routine
   // at which point everything better have been deallocated
   //
   IoDeleteDevice( PDevObj );

   DbgDump(DBG_INIT, ("<DeleteDevObjAndSymLink\n"));

   return NtStatus;
}

#if 0

VOID
SetBooleanLocked(
   IN OUT PBOOLEAN PDest,
   IN BOOLEAN      Src,
   IN PKSPIN_LOCK  PSpinLock
   )
/*++

Routine Description:

    This function is used to assign a BOOLEAN value with spinlock protection.

Arguments:

    PDest - A pointer to Lval.

    Src - Rval.

    PSpinLock - Pointer to the spin lock we should hold.

Return Value:

    None.

--*/
{
  KIRQL tmpIrql;

  KeAcquireSpinLock(PSpinLock, &tmpIrql);
  *PDest = Src;
  KeReleaseSpinLock(PSpinLock, tmpIrql);
}
#endif


VOID
SetPVoidLocked(
   IN OUT PVOID *PDest,
   IN OUT PVOID Src,
   IN PKSPIN_LOCK PSpinLock
   )
{
  KIRQL tmpIrql;

  KeAcquireSpinLock(PSpinLock, &tmpIrql);
  *PDest = Src;
  KeReleaseSpinLock(PSpinLock, tmpIrql);
}


//
// Note: had to use ExWorkItems to be binary compatible with Win98.
// The WorkerRoutine must take as it's only parameter a PWCE_WORK_ITEM
// and extract any parameters. When the WorkerRoutine is complete is MUST
// call DequeueWorkItem to free it back to the worker pool & signal any waiters.
//
NTSTATUS
QueueWorkItem(
   IN PDEVICE_OBJECT PDevObj,
   IN PWCE_WORKER_THREAD_ROUTINE WorkerRoutine,
   IN PVOID Context,
   IN ULONG Flags
   )
{
   PDEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
   NTSTATUS status = STATUS_INVALID_PARAMETER;
   PWCE_WORK_ITEM pWorkItem;
   KIRQL irql;

   DbgDump(DBG_WORK_ITEMS, (">QueueWorkItem\n" ));

   //
   // N.B: you need to ensure your driver does not queue anything when it is stopped.
   //
   KeAcquireSpinLock(&pDevExt->ControlLock, &irql);

   if ( !CanAcceptIoRequests(PDevObj, FALSE, TRUE) ) {

      status = STATUS_DELETE_PENDING;
      DbgDump(DBG_ERR, ("QueueWorkItem: 0x%x\n", status));

   } else if ( PDevObj && WorkerRoutine ) {

      pWorkItem = ExAllocateFromNPagedLookasideList( &pDevExt->WorkItemPool );

      if ( pWorkItem ) {

         status = AcquireRemoveLock(&pDevExt->RemoveLock, pWorkItem);
         if ( !NT_SUCCESS(status) ) {
             DbgDump(DBG_ERR, ("QueueWorkItem: 0x%x\n", status));
             TEST_TRAP();
             ExFreeToNPagedLookasideList( &pDevExt->WorkItemPool, pWorkItem );
             KeReleaseSpinLock(&pDevExt->ControlLock, irql);
             return status;
         }

         RtlZeroMemory( pWorkItem, sizeof(*pWorkItem) );

         // bump the pending count
         InterlockedIncrement(&pDevExt->PendingWorkItemsCount);

         DbgDump(DBG_WORK_ITEMS, ("PendingWorkItemsCount: %d\n", pDevExt->PendingWorkItemsCount));

         //
         // put the worker on our pending list
         //
         InsertTailList(&pDevExt->PendingWorkItems,
                        &pWorkItem->ListEntry );

         //
         // store parameters
         //
         pWorkItem->DeviceObject = PDevObj;
         pWorkItem->Context = Context;
         pWorkItem->Flags = Flags;

         ExInitializeWorkItem( &pWorkItem->Item,
                               (PWORKER_THREAD_ROUTINE)WorkerRoutine,
                               (PVOID)pWorkItem // Context passed to WorkerRoutine
                              );

         // finally, queue the worker
         ExQueueWorkItem( &pWorkItem->Item,
                          CriticalWorkQueue );

         status = STATUS_SUCCESS;

      } else {
         status = STATUS_INSUFFICIENT_RESOURCES;
         DbgDump(DBG_ERR, ("AllocateWorkItem failed!\n"));
         TEST_TRAP()
      }
   }

   KeReleaseSpinLock(&pDevExt->ControlLock, irql);

   DbgDump(DBG_WORK_ITEMS, ("<QueueWorkItem 0x%x\n", status ));

   return status;
}


VOID
DequeueWorkItem(
   IN PDEVICE_OBJECT PDevObj,
   IN PWCE_WORK_ITEM PWorkItem
   )
{
   PDEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
   KIRQL irql;

   DbgDump(DBG_WORK_ITEMS, (">DequeueWorkItem\n" ));

   //
   // remove the worker from the pending list
   //
   KeAcquireSpinLock( &pDevExt->ControlLock,  &irql );

   RemoveEntryList( &PWorkItem->ListEntry );

   KeReleaseSpinLock( &pDevExt->ControlLock, irql);

   //
   // free the worker back to pool
   //
   ExFreeToNPagedLookasideList( &pDevExt->WorkItemPool, PWorkItem );

   //
   // signal event if this is the last one
   //
   if (0 == InterlockedDecrement( &pDevExt->PendingWorkItemsCount) ) {
      DbgDump(DBG_WORK_ITEMS, ("PendingWorkItemsEvent signalled\n" ));
      KeSetEvent( &pDevExt->PendingWorkItemsEvent, IO_NO_INCREMENT, FALSE);
   }
   DbgDump(DBG_WORK_ITEMS, ("PendingWorkItemsCount: %d\n", pDevExt->PendingWorkItemsCount));
   ASSERT(pDevExt->PendingWorkItemsCount >= 0);

   ReleaseRemoveLock(&pDevExt->RemoveLock, PWorkItem);

   DbgDump(DBG_WORK_ITEMS, ("<DequeueWorkItem\n" ));

   return;
}


#pragma warning( push )
#pragma warning( disable : 4706 ) // assignment w/i conditional expression
NTSTATUS
WaitForPendingItem(
   IN PDEVICE_OBJECT PDevObj,
   IN PKEVENT PPendingEvent,
   IN PULONG  PPendingCount
   )
{
   PDEVICE_EXTENSION pDevExt = PDevObj->DeviceExtension;
   LARGE_INTEGER  timeOut = {0,0};
   LONG itemsLeft;
   NTSTATUS status = STATUS_SUCCESS;

   DbgDump(DBG_PNP, (">WaitForPendingItem\n"));

   if ( !PDevObj || !PPendingEvent || !PPendingCount ) {

      status = STATUS_INVALID_PARAMETER;
      DbgDump(DBG_ERR, ("WaitForPendingItem: STATUS_INVALID_PARAMETER\n"));
      TEST_TRAP();

   } else {

      //
      // wait for pending item to signal it's complete
      //
      while ( itemsLeft = InterlockedExchange( PPendingCount, *PPendingCount) ) {

         DbgDump(DBG_PNP|DBG_EVENTS, ("Pending Items Remain: %d\n", itemsLeft ) );

         timeOut.QuadPart = MILLISEC_TO_100NANOSEC( DEFAULT_PENDING_TIMEOUT );

         DbgDump(DBG_PNP|DBG_EVENTS, ("Waiting for %d msec...\n", timeOut.QuadPart/10000));

         PAGED_CODE();

         KeWaitForSingleObject( PPendingEvent,
                                Executive,
                                KernelMode,
                                FALSE,
                                &timeOut );

      }

      DbgDump(DBG_PNP, ("Pending Items: %d\n", itemsLeft ) );
   }

   DbgDump(DBG_PNP, ("<WaitForPendingItem (0x%x)\n", status));

   return status;
}
#pragma warning( pop )


BOOLEAN
CanAcceptIoRequests(
   IN PDEVICE_OBJECT DeviceObject,
   IN BOOLEAN        AcquireLock,
   IN BOOLEAN        CheckOpened
   )
/*++

Routine Description:

  Check device extension status flags.
  Can NOT accept a new I/O request if device:
      1) is removed,
      2) has never been started,
      3) is stopped,
      4) has a remove request pending, or
      5) has a stop device pending

  ** Called with the SpinLock held, else AcquireLock should be TRUE **

Arguments:

    DeviceObject - pointer to the device object
    AcquireLock  - if TRUE then we need to acquire the lock
    CheckOpened  - normally set to TRUE during I/O.
                   Special cases where FALSE include:
                   IRP_MN_QUERY_PNP_DEVICE_STATE
                   IRP_MJ_CREATE

Return Value:

    TRUE/FALSE

--*/
{
    PDEVICE_EXTENSION pDevExt = DeviceObject->DeviceExtension;
    BOOLEAN bRc = FALSE;
    KIRQL   irql;

    if (AcquireLock) {
        KeAcquireSpinLock(&pDevExt->ControlLock, &irql);
    }

    if ( !InterlockedCompareExchange(&pDevExt->DeviceRemoved, FALSE, FALSE) &&
          InterlockedCompareExchange(&pDevExt->AcceptingRequests, TRUE, TRUE) &&
          InterlockedCompareExchange((PULONG)&pDevExt->PnPState, PnPStateStarted, PnPStateStarted) &&
          (CheckOpened ? InterlockedCompareExchange(&pDevExt->DeviceOpened, TRUE, TRUE) : TRUE)
       )
    {
        bRc = TRUE;
    }
#if defined(DBG)
    else DbgDump(DBG_WRN|DBG_PNP, ("CanAcceptIoRequests = FALSE\n"));
#endif

    if (AcquireLock) {
        KeReleaseSpinLock(&pDevExt->ControlLock, irql);
    }

    return bRc;
}


BOOLEAN
IsWin9x(
   VOID
   )
/*++

Routine Description:

    Determine whether or not we are running on Win9x (vs. NT).

Arguments:


Return Value:

    TRUE iff we're running on Win9x.

--*/
{
    OBJECT_ATTRIBUTES objectAttributes;
    UNICODE_STRING keyName;
    HANDLE hKey;
    NTSTATUS status;
    BOOLEAN result;

    PAGED_CODE();

    /*
     *  Try to open the COM Name Arbiter, which exists only on NT.
     */
    RtlInitUnicodeString(&keyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\COM Name Arbiter");
    InitializeObjectAttributes( &objectAttributes,
                                &keyName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                (PSECURITY_DESCRIPTOR)NULL);

    status = ZwOpenKey(&hKey, KEY_QUERY_VALUE, &objectAttributes);
    if (NT_SUCCESS(status)){
        status = ZwClose(hKey);
        ASSERT(NT_SUCCESS(status));
        result = FALSE;
    }
    else {
        result = TRUE;
    }

    return result;
}



VOID
LogError(
   IN PDRIVER_OBJECT DriverObject,
   IN PDEVICE_OBJECT DeviceObject OPTIONAL,
   IN ULONG SequenceNumber,
   IN UCHAR MajorFunctionCode,
   IN UCHAR RetryCount,
   IN ULONG UniqueErrorValue,
   IN NTSTATUS FinalStatus,
   IN NTSTATUS SpecificIOStatus,
   IN ULONG LengthOfInsert1,
   IN PWCHAR Insert1,
   IN ULONG LengthOfInsert2,
   IN PWCHAR Insert2
   )

/*++

Routine Description:

    Stolen from serial.sys

    This routine allocates an error log entry, copies the supplied data
    to it, and requests that it be written to the error log file.

Arguments:

    DriverObject - A pointer to the driver object for the device.

    DeviceObject - A pointer to the device object associated with the
    device that had the error, early in initialization, one may not
    yet exist.

    SequenceNumber - A ulong value that is unique to an IRP over the
    life of the irp in this driver - 0 generally means an error not
    associated with an irp.

    MajorFunctionCode - If there is an error associated with the irp,
    this is the major function code of that irp.

    RetryCount - The number of times a particular operation has been
    retried.

    UniqueErrorValue - A unique long word that identifies the particular
    call to this function.

    FinalStatus - The final status given to the irp that was associated
    with this error.  If this log entry is being made during one of
    the retries this value will be STATUS_SUCCESS.

    SpecificIOStatus - The IO status for a particular error.

    LengthOfInsert1 - The length in bytes (including the terminating NULL)
                      of the first insertion string.

    Insert1 - The first insertion string.

    LengthOfInsert2 - The length in bytes (including the terminating NULL)
                      of the second insertion string.  NOTE, there must
                      be a first insertion string for their to be
                      a second insertion string.

    Insert2 - The second insertion string.

Return Value:

    None.

--*/

{
   PIO_ERROR_LOG_PACKET errorLogEntry;

   PVOID objectToUse = NULL;
   SHORT dumpToAllocate = 0;
   PUCHAR ptrToFirstInsert = NULL;
   PUCHAR ptrToSecondInsert = NULL;

   PAGED_CODE();

   DbgDump(DBG_ERR, (">LogError\n"));

   if (Insert1 == NULL) {
      LengthOfInsert1 = 0;
   }

   if (Insert2 == NULL) {
      LengthOfInsert2 = 0;
   }

   if (ARGUMENT_PRESENT(DeviceObject)) {

      objectToUse = DeviceObject;

   } else if (ARGUMENT_PRESENT(DriverObject)) {

      objectToUse = DriverObject;

   }

   errorLogEntry = IoAllocateErrorLogEntry(
                                          objectToUse,
                                          (UCHAR)(sizeof(IO_ERROR_LOG_PACKET) +
                                                  dumpToAllocate
                                                  + LengthOfInsert1 +
                                                  LengthOfInsert2)
                                          );

   if ( errorLogEntry != NULL ) {

      errorLogEntry->ErrorCode = SpecificIOStatus;
      errorLogEntry->SequenceNumber = SequenceNumber;
      errorLogEntry->MajorFunctionCode = MajorFunctionCode;
      errorLogEntry->RetryCount = RetryCount;
      errorLogEntry->UniqueErrorValue = UniqueErrorValue;
      errorLogEntry->FinalStatus = FinalStatus;
      errorLogEntry->DumpDataSize = dumpToAllocate;
         ptrToFirstInsert = (PUCHAR)&errorLogEntry->DumpData[0];

      ptrToSecondInsert = ptrToFirstInsert + LengthOfInsert1;

      if (LengthOfInsert1) {

         errorLogEntry->NumberOfStrings = 1;
         errorLogEntry->StringOffset = (USHORT)(ptrToFirstInsert -
                                                (PUCHAR)errorLogEntry);
         RtlCopyMemory(
                      ptrToFirstInsert,
                      Insert1,
                      LengthOfInsert1
                      );

         if (LengthOfInsert2) {

            errorLogEntry->NumberOfStrings = 2;
            RtlCopyMemory(
                         ptrToSecondInsert,
                         Insert2,
                         LengthOfInsert2
                         );

         }

      }

      IoWriteErrorLogEntry(errorLogEntry);

   }

   DbgDump(DBG_ERR, ("<LogError\n"));
   return;
}


#if defined(DBG)
PCHAR
PnPMinorFunctionString (
   UCHAR MinorFunction
   )
{
    switch (MinorFunction) {
        case IRP_MN_START_DEVICE:
            return "IRP_MN_START_DEVICE";
        case IRP_MN_QUERY_REMOVE_DEVICE:
            return "IRP_MN_QUERY_REMOVE_DEVICE";
        case IRP_MN_REMOVE_DEVICE:
            return "IRP_MN_REMOVE_DEVICE";
        case IRP_MN_CANCEL_REMOVE_DEVICE:
            return "IRP_MN_CANCEL_REMOVE_DEVICE";
        case IRP_MN_STOP_DEVICE:
            return "IRP_MN_STOP_DEVICE";
        case IRP_MN_QUERY_STOP_DEVICE:
            return "IRP_MN_QUERY_STOP_DEVICE";
        case IRP_MN_CANCEL_STOP_DEVICE:
            return "IRP_MN_CANCEL_STOP_DEVICE";
        case IRP_MN_QUERY_DEVICE_RELATIONS:
            return "IRP_MN_QUERY_DEVICE_RELATIONS";
        case IRP_MN_QUERY_INTERFACE:
            return "IRP_MN_QUERY_INTERFACE";
        case IRP_MN_QUERY_CAPABILITIES:
            return "IRP_MN_QUERY_CAPABILITIES";
        case IRP_MN_QUERY_RESOURCES:
            return "IRP_MN_QUERY_RESOURCES";
        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
            return "IRP_MN_QUERY_RESOURCE_REQUIREMENTS";
        case IRP_MN_QUERY_DEVICE_TEXT:
            return "IRP_MN_QUERY_DEVICE_TEXT";
        case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
            return "IRP_MN_FILTER_RESOURCE_REQUIREMENTS";
        case IRP_MN_READ_CONFIG:
            return "IRP_MN_READ_CONFIG";
        case IRP_MN_WRITE_CONFIG:
            return "IRP_MN_WRITE_CONFIG";
        case IRP_MN_EJECT:
            return "IRP_MN_EJECT";
        case IRP_MN_SET_LOCK:
            return "IRP_MN_SET_LOCK";
        case IRP_MN_QUERY_ID:
            return "IRP_MN_QUERY_ID";
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
            return "IRP_MN_QUERY_PNP_DEVICE_STATE";
        case IRP_MN_QUERY_BUS_INFORMATION:
            return "IRP_MN_QUERY_BUS_INFORMATION";
        case IRP_MN_DEVICE_USAGE_NOTIFICATION:
            return "IRP_MN_DEVICE_USAGE_NOTIFICATION";
        case IRP_MN_SURPRISE_REMOVAL:
            return "IRP_MN_SURPRISE_REMOVAL";
        default:
            return ((PCHAR)("unknown IRP_MN_ 0x%x\n", MinorFunction));
    }
}
#endif

// EOF