/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
local.h
Abstract
Definitions that are private to the hid class driver code appear here.
Author:
Ervin P.
Environment:
Kernel mode only
Revision History:
--*/
typedef struct _HID_DESCRIPTOR *PHID_DESCRIPTOR;
typedef struct _HIDCLASS_COLLECTION *PHIDCLASS_COLLECTION;
typedef struct _HIDCLASS_DEVICE_EXTENSION *PHIDCLASS_DEVICE_EXTENSION;
typedef struct _HIDCLASS_DRIVER_EXTENSION *PHIDCLASS_DRIVER_EXTENSION;
typedef struct _HIDCLASS_FILE_EXTENSION *PHIDCLASS_FILE_EXTENSION;
typedef struct _HIDCLASS_PINGPONG *PHIDCLASS_PINGPONG;
typedef struct _HIDCLASS_REPORT *PHIDCLASS_REPORT;
typedef struct _FDO_EXTENSION *PFDO_EXTENSION;
typedef struct _PDO_EXTENSION *PPDO_EXTENSION;
#if DBG
#define LockFileExtension( f, i ) \
{ \
KeAcquireSpinLock( &(f)->ListSpinLock, (i) ); \
(f)->ListSpinLockTaken = TRUE; \
}
#define UnlockFileExtension(f, i) \
{ \
(f)->ListSpinLockTaken = FALSE; \
KeReleaseSpinLock( &(f)->ListSpinLock, (i) ); \
}
VOID DbgLogIntStart();
VOID DbgLogIntEnd();
#define DBGLOG_INTSTART() DbgLogIntStart();
#define DBGLOG_INTEND() DbgLogIntEnd();
VOID DbgTestGetDeviceString(PFDO_EXTENSION fdoExt);
VOID DbgTestGetIndexedString(PFDO_EXTENSION fdoExt);
#else
#define LockFileExtension(f, i) KeAcquireSpinLock(&(f)->ListSpinLock, (i));
#define UnlockFileExtension(f, i) KeReleaseSpinLock(&(f)->ListSpinLock, (i));
#define DBGLOG_INTSTART()
#define DBGLOG_INTEND()
#endif
#define HIDCLASS_POOL_TAG 'CdiH'
#define ALLOCATEPOOL(poolType, size) ExAllocatePoolWithTag((poolType), (size), HIDCLASS_POOL_TAG)
//
// On some busses, we can power down the bus, but not the system, in this case
// we still need to allow the device to wake said bus, therefore
// waitwake-supported should not rely on systemstate.
//
#define WAITWAKE_SUPPORTED(fdoExt) ((fdoExt)->deviceCapabilities.DeviceWake > PowerDeviceD0 && \
(fdoExt)->deviceCapabilities.SystemWake > PowerSystemWorking)
// #define WAITWAKE_ON(port) ((port)->WaitWakeIrp != 0)
#define REMOTEWAKE_ON(port) \
(InterlockedCompareExchangePointer(&(port)->remoteWakeIrp, NULL, NULL) != NULL)
BOOLEAN
HidpCheckRemoteWakeEnabled(
IN PPDO_EXTENSION PdoExt
);
#define SHOULD_SEND_WAITWAKE(pdoExt) (!(pdoExt)->MouseOrKeyboard && \
WAITWAKE_SUPPORTED(&(pdoExt)->deviceFdoExt->fdoExt) && \
!REMOTEWAKE_ON(pdoExt) && \
HidpCheckRemoteWakeEnabled(pdoExt))
/*
* String constants for use in compatible-id multi-string.
*/
// 0123456789 123456789 1234
#define HIDCLASS_COMPATIBLE_ID_STANDARD_NAME L"HID_DEVICE\0"
#define HIDCLASS_COMPATIBLE_ID_GENERIC_NAME L"HID_DEVICE_UP:%04x_U:%04x\0"
#define HIDCLASS_COMPATIBLE_ID_PAGE_OFFSET 14
#define HIDCLASS_COMPATIBLE_ID_USAGE_OFFSET 21
#define HIDCLASS_COMPATIBLE_ID_STANDARD_LENGTH 11
#define HIDCLASS_COMPATIBLE_ID_GENERIC_LENGTH 26
// 0123456789 123456789 123456
#define HIDCLASS_SYSTEM_KEYBOARD L"HID_DEVICE_SYSTEM_KEYBOARD\0"
#define HIDCLASS_SYSTEM_MOUSE L"HID_DEVICE_SYSTEM_MOUSE\0"
#define HIDCLASS_SYSTEM_GAMING_DEVICE L"HID_DEVICE_SYSTEM_GAME\0"
#define HIDCLASS_SYSTEM_CONTROL L"HID_DEVICE_SYSTEM_CONTROL\0"
#define HIDCLASS_SYSTEM_CONSUMER_DEVICE L"HID_DEVICE_SYSTEM_CONSUMER\0"
//
// String constant used to find out if selective suspend
// is supported on this device.
//
#define HIDCLASS_SELECTIVE_SUSPEND_ENABLED L"SelectiveSuspendEnabled\0"
#define HIDCLASS_SELECTIVE_SUSPEND_ON L"SelectiveSuspendOn\0"
#define HIDCLASS_REMOTE_WAKE_ENABLE L"RemoteWakeEnabled"
#define NO_STATUS 0x80000000 // this will never be a STATUS_xxx constant in NTSTATUS.H
#define HID_DEFAULT_IDLE_TIME 5 // in seconds
//
// Valid values for HIDCLASS_DEVICE_EXTENSION.state
//
enum deviceState {
DEVICE_STATE_INITIALIZED = 1,
DEVICE_STATE_STARTING,
DEVICE_STATE_START_SUCCESS,
DEVICE_STATE_START_FAILURE,
DEVICE_STATE_STOPPING,
DEVICE_STATE_STOPPED,
DEVICE_STATE_REMOVING,
DEVICE_STATE_REMOVED
};
enum collectionState {
COLLECTION_STATE_UNINITIALIZED = 1,
COLLECTION_STATE_INITIALIZED,
COLLECTION_STATE_RUNNING,
COLLECTION_STATE_STOPPING,
COLLECTION_STATE_STOPPED,
COLLECTION_STATE_REMOVING
};
//
// _HIDCLASS_DRIVER_EXTENSION contains per-minidriver extension information
// for the class driver. It is created upon a HidRegisterMinidriver() call.
//
typedef struct _HIDCLASS_DRIVER_EXTENSION {
//
// Pointer to the minidriver's driver object.
//
PDRIVER_OBJECT MinidriverObject;
//
// RegistryPath is a copy of the minidriver's RegistryPath that it
// received as a DriverEntry() parameter.
//
UNICODE_STRING RegistryPath;
//
// DeviceExtensionSize is the size of the minidriver's per-device
// extension.
//
ULONG DeviceExtensionSize;
//
// Dispatch routines for the minidriver. These are the only dispatch
// routines that the minidriver should ever care about, no others will
// be forwarded.
//
PDRIVER_DISPATCH MajorFunction[ IRP_MJ_MAXIMUM_FUNCTION + 1 ];
/*
* These are the minidriver's original entrypoints,
* to which we chain.
*/
PDRIVER_ADD_DEVICE AddDevice;
PDRIVER_UNLOAD DriverUnload;
//
// Number of pointers to this structure that we've handed out
//
LONG ReferenceCount;
//
// Linkage onto our global list of driver extensions
//
LIST_ENTRY ListEntry;
/*
* Either all or none of the devices driven by a given minidriver are polled.
*/
BOOLEAN DevicesArePolled;
#if DBG
ULONG Signature;
#endif
} HIDCLASS_DRIVER_EXTENSION;
#if DBG
#define HID_DRIVER_EXTENSION_SIG 'EdiH'
#endif
#define MIN_POLL_INTERVAL_MSEC 1
#define MAX_POLL_INTERVAL_MSEC 10000
#define DEFAULT_POLL_INTERVAL_MSEC 5
/*
* Device-specific flags
*/
// Nanao depends on a Win98G bug that allows GetFeature on input collection
#define DEVICE_FLAG_ALLOW_FEATURE_ON_NON_FEATURE_COLLECTION (1 << 0)
//
// HIDCLASS_COLLECTION is where we keep our per-collection information.
//
typedef struct _HIDCLASS_COLLECTION {
ULONG CollectionNumber;
ULONG CollectionIndex;
//
// NumOpens is a count of open handles against this collection.
//
ULONG NumOpens;
// Number of pending reads for all clients on this collection.
ULONG numPendingReads;
//
// FileExtensionList is the head of a list of file extensions, i.e.
// open instances against this collection.
//
LIST_ENTRY FileExtensionList;
KSPIN_LOCK FileExtensionListSpinLock;
/*
* For polled devices, we only read from the device
* once every poll interval. We queue read IRPs
* here until the poll timer expiration.
*
* Note: for a polled device, we keep a separate background
* loop for each collection. This way, queued-up read IRPs
* remain associated with the right collection.
* Also, this will keep the number of reads we do on each
* timer period roughly equal to the number of collections.
*/
ULONG PollInterval_msec;
KTIMER polledDeviceTimer;
KDPC polledDeviceTimerDPC;
LIST_ENTRY polledDeviceReadQueue;
KSPIN_LOCK polledDeviceReadQueueSpinLock;
/*
* We save old reports on polled devices for
* "opportunistic" readers who want to get a result right away.
* The polledDataIsStale flag indicates that the saved report
* is at least one poll interval old (so we should not use it).
*/
PUCHAR savedPolledReportBuf;
ULONG savedPolledReportLen;
BOOLEAN polledDataIsStale;
UNICODE_STRING SymbolicLinkName;
UNICODE_STRING SymbolicLinkName_SystemControl;
/*
* HID collection information descriptor for this collection.
*/
HID_COLLECTION_INFORMATION hidCollectionInfo;
PHIDP_PREPARSED_DATA phidDescriptor;
/*
* This buffer is used to "cook" a raw report when it's been received.
* This is only used for non-polled (interrupt) devices.
*/
PUCHAR cookedInterruptReportBuf;
/*
* This is an IRP that we queue and complete
* when a read report contains a power event.
*
* The powerEventIrp field retains an IRP
* so it needs a spinlock to synchronize cancellation.
*/
PIRP powerEventIrp;
KSPIN_LOCK powerEventSpinLock;
ULONG secureReadMode;
KSPIN_LOCK secureReadLock;
#if DBG
ULONG Signature;
#endif
} HIDCLASS_COLLECTION;
#if DBG
#define HIDCLASS_COLLECTION_SIG 'EccH'
#endif
//
// For HID devices that have at least one interrupt-style collection, we
// try to keep a set of "ping-pong" report-read IRPs pending in the minidriver
// in the event we get a report.
//
// HIDCLASS_PINGPONG contains a pointer to an IRP as well as an event
// and status block. Each device has a pointer to an array of these structures,
// the array size depending on the number of such IRPs we want to keep in
// motion.
//
// Right now the default number is 2.
//
#define MIN_PINGPONG_IRPS 2
//
// Flags to indicate whether read completed synchronously or asynchronously
//
#define PINGPONG_START_READ 0x01
#define PINGPONG_END_READ 0x02
#define PINGPONG_IMMEDIATE_READ 0x03
typedef struct _HIDCLASS_PINGPONG {
#define PINGPONG_SIG (ULONG)'gnoP'
ULONG sig;
//
// Read interlock value to protect us from running out of stack space
//
ULONG ReadInterlock;
PIRP irp;
PUCHAR reportBuffer;
LONG weAreCancelling;
KEVENT sentEvent; // When a read has been sent.
KEVENT pumpDoneEvent; // When the read loop is finally exitting.
PFDO_EXTENSION myFdoExt;
/*
* Timeout context for back-off algorithm applied to broken devices.
*/
KTIMER backoffTimer;
KDPC backoffTimerDPC;
LARGE_INTEGER backoffTimerPeriod; // in negative 100-nsec units
} HIDCLASS_PINGPONG;
#if DBG
#define HIDCLASS_REPORT_BUFFER_GUARD 'draG'
#endif
//
// All possible idle states.
//
#define IdleUninitialized 0x0
#define IdleDisabled 0x1
#define IdleWaiting 0x2
#define IdleIrpSent 0x3
#define IdleCallbackReceived 0x4
#define IdleComplete 0x5
/*
* Stores information about a Functional Device Object (FDO) which HIDCLASS attaches
* to the top of the Physical Device Object (PDO) that it get from the minidriver below.
*/
typedef struct _FDO_EXTENSION {
//
// Back pointer to the functional device object
//
PDEVICE_OBJECT fdo;
//
// HidDriverExtension is a pointer to our driver extension for the
// minidriver that gave us the PDO.
//
PHIDCLASS_DRIVER_EXTENSION driverExt;
//
// Hid descriptor that we get from the device.
//
HID_DESCRIPTOR hidDescriptor; // 9 bytes
//
// The attributes of this hid device.
//
HID_DEVICE_ATTRIBUTES hidDeviceAttributes; // 0x20 bytes
//
// Pointer to and length of the raw report descriptor.
//
PUCHAR rawReportDescription;
ULONG rawReportDescriptionLength;
//
// This device has one or more collections. We store the count and
// pointer to an array of our HIDCLASS_COLLECTION structures (one per
// collection) here.
//
PHIDCLASS_COLLECTION classCollectionArray;
/*
* This is initialized for us by HIDPARSE's HidP_GetCollectionDescription().
* It includes an array of HIDP_COLLECTION_DESC structs corresponding
* the classCollectionArray declared above.
*/
HIDP_DEVICE_DESC deviceDesc; // 0x30 bytes
BOOLEAN devDescInitialized;
//
// The maximum input size amongst ALL report types.
//
ULONG maxReportSize;
//
// For devices that have at least one interrupt collection, we keep
// a couple of ping-pong IRPs and associated structures.
// The ping-pong IRPs ferry data up from the USB hub.
//
ULONG numPingPongs;
PHIDCLASS_PINGPONG pingPongs;
//
// OpenCount represents the number of file objects aimed at this device
//
ULONG openCount;
/*
* This is the number of IRPs still outstanding in the minidriver.
*/
ULONG outstandingRequests;
enum deviceState prevState;
enum deviceState state;
UNICODE_STRING name;
/*
* deviceRelations contains an array of client PDO pointers.
*
* As the HID bus driver, HIDCLASS produces this data structure to report
* collection-PDOs to the system.
*/
PDEVICE_RELATIONS deviceRelations;
/*
* This is an array of device extensions for the collection-PDOs of this
* device-FDO.
*/
PHIDCLASS_DEVICE_EXTENSION *collectionPdoExtensions;
/*
* This includes a
* table mapping system power states to device power states.
*/
DEVICE_CAPABILITIES deviceCapabilities;
/*
* Track both current system and device power state
*/
SYSTEM_POWER_STATE systemPowerState;
DEVICE_POWER_STATE devicePowerState;
/*
* Wait Wake Irp sent to parent PDO
*/
PIRP waitWakeIrp;
KSPIN_LOCK waitWakeSpinLock;
BOOLEAN isWaitWakePending;
/*
* Queue of delayed requests due to the stack being in low power
*/
KSPIN_LOCK collectionPowerDelayedIrpQueueSpinLock;
LIST_ENTRY collectionPowerDelayedIrpQueue;
ULONG numPendingPowerDelayedIrps;
BOOLEAN isOutputOnlyDevice;
//
// Selective suspend idling context.
//
HID_SUBMIT_IDLE_NOTIFICATION_CALLBACK_INFO idleCallbackInfo;
LONG idleState;
PULONG idleTimeoutValue;
KSPIN_LOCK idleNotificationSpinLock;
PIRP idleNotificationRequest;
BOOLEAN idleCancelling;
BOOLEAN idleEnabledInRegistry;
BOOLEAN idleEnabled;
KSPIN_LOCK idleSpinLock;
KEVENT idleDoneEvent; // When the idle notification irp has been cancelled successfully.
LONG numIdlePdos;
/*
* This is a list of WaitWake IRPs sent to the collection-PDOs
* on this device, which we just save and complete when the
* base device's WaitWake IRP completes.
*/
LIST_ENTRY collectionWaitWakeIrpQueue;
KSPIN_LOCK collectionWaitWakeIrpQueueSpinLock;
struct _FDO_EXTENSION *nextFdoExt;
/*
* Device-specific flags (DEVICE_FLAG_xxx).
*/
ULONG deviceSpecificFlags;
/*
* This is our storage space for the systemState IRP that we need to hold
* on to and complete in DevicePowerRequestCompletion.
*/
PIRP currentSystemStateIrp;
/*
* Unique number assigned to identify this HID bus.
*/
ULONG BusNumber;
//
// WMI Information
//
WMILIB_CONTEXT WmiLibInfo;
#if DBG
WCHAR dbgDriverKeyName[64];
#endif
} FDO_EXTENSION;
/*
* Stores information about a Physical Device Object (PDO) which HIDCLASS creates
* for each HID device-collection.
*/
typedef struct _PDO_EXTENSION {
enum collectionState prevState;
enum collectionState state;
ULONG collectionNum;
ULONG collectionIndex;
//
// A remove lock to keep track of outstanding I/Os to prevent the device
// object from leaving before such time as all I/O has been completed.
//
IO_REMOVE_LOCK removeLock;
// represents a collection on the HID "bus"
PDEVICE_OBJECT pdo;
PUNICODE_STRING name;
/*
* This is a back-pointer to the original FDO's extension.
*/
PHIDCLASS_DEVICE_EXTENSION deviceFdoExt;
/*
* Track both current system and device power state
*/
SYSTEM_POWER_STATE systemPowerState;
DEVICE_POWER_STATE devicePowerState;
BOOLEAN remoteWakeEnabled;
KSPIN_LOCK remoteWakeSpinLock;
PIRP remoteWakeIrp;
PIRP waitWakeIrp;
/*
* The status change function that was registered thru query interface
* NOTE: Can currently only register one.
*/
PHID_STATUS_CHANGE StatusChangeFn;
PVOID StatusChangeContext;
/*
* Access protection information.
* We count the number of opens for read and write on the collection.
* We also count the number of opens which RESTRICT future
* read/write opens on the collection.
*
* Note that desired access is independent of restriction.
* A client may, for example, do an open-for-read-only but
* (by not setting the FILE_SHARE_WRITE bit)
* restrict other clients from doing an open-for-write.
*/
ULONG openCount;
ULONG opensForRead;
ULONG opensForWrite;
ULONG restrictionsForRead;
ULONG restrictionsForWrite;
ULONG restrictionsForAnyOpen;
BOOLEAN MouseOrKeyboard;
//
// WMI Information
//
WMILIB_CONTEXT WmiLibInfo;
} PDO_EXTENSION;
/*
* This contains info about either a device FDO or a device-collection PDO.
* Some of the same functions process both, so we need one structure.
*/
typedef struct _HIDCLASS_DEVICE_EXTENSION {
/*
* This is the public part of a HID FDO device extension, and
* must be the first entry in this structure.
*/
HID_DEVICE_EXTENSION hidExt; // size== 0x0C.
/*
* Determines whether this is a device extension for a device-FDO or a
* device-collection-PDO; this resolves the following union.
*/
BOOLEAN isClientPdo;
/*
* Include this signature for both debug and retail --
* kenray's debug extensions look for this.
*/
#define HID_DEVICE_EXTENSION_SIG 'EddH'
ULONG Signature;
union {
FDO_EXTENSION fdoExt;
PDO_EXTENSION pdoExt;
};
} HIDCLASS_DEVICE_EXTENSION;
//
// HIDCLASS_FILE_EXTENSION is private data we keep per file object.
//
typedef struct _HIDCLASS_FILE_EXTENSION {
//
// CollectionNumber is the ordinal of the collection in the device
//
ULONG CollectionNumber;
PFDO_EXTENSION fdoExt;
//
// PendingIrpList is a list of READ IRPs currently waiting to be satisfied.
//
LIST_ENTRY PendingIrpList;
//
// ReportList is a list of reports waiting to be read on this handle.
//
LIST_ENTRY ReportList;
//
// FileList provides a way to link all of a collection's
// file extensions together.
//
LIST_ENTRY FileList;
//
// Both PendingIrpList and ReportList are protected by the same spinlock,
// ListSpinLock.
//
KSPIN_LOCK ListSpinLock;
//
// MaximumInputReportAge is only applicable for polled collections.
// It represents the maximum acceptable input report age for this handle.
// There is a value in the HIDCLASS_COLLECTION,
// CurrentMaximumInputReportAge, that represents the current minimum value
// of all of the file extensions open against the collection.
//
LARGE_INTEGER MaximumInputReportAge;
//
// CurrentInputReportQueueSize is the current size of the report input
// queue.
//
ULONG CurrentInputReportQueueSize;
/*
* This is the maximum number of reports that will be queued for the file extension.
* This starts at a default value and can be adjusted (within a fixed range) by an IOCTL.
*/
ULONG MaximumInputReportQueueSize;
#define MIN_INPUT_REPORT_QUEUE_SIZE MIN_PINGPONG_IRPS
#define MAX_INPUT_REPORT_QUEUE_SIZE (MIN_INPUT_REPORT_QUEUE_SIZE*256)
#define DEFAULT_INPUT_REPORT_QUEUE_SIZE (MIN_INPUT_REPORT_QUEUE_SIZE*16)
//
// Back pointer to the file object that this extension is for
//
PFILE_OBJECT FileObject;
/*
* File-attributes passed in irpSp->Parameters.Create.FileAttributes
* when this open was made.
*/
USHORT FileAttributes;
ACCESS_MASK accessMask;
USHORT shareMask;
//
// Closing is set when this file object is closing and will be removed
// shortly. Don't queue any more reports or IRPs to this object
// when this flag is set.
//
BOOLEAN Closing;
//
// Security has been checked.
//
BOOLEAN SecurityCheck;
//
// DWORD allignment
//
BOOLEAN Reserved [2];
/*
* This flag indicates that this client does irregular, opportunistic
* reads on the device, which is a polled device.
* Instead of waiting for the background timer-driven read loop,
* this client should have his reads completed immediately.
*/
BOOLEAN isOpportunisticPolledDeviceReader;
ULONG nowCompletingIrpForOpportunisticReader;
/*
* haveReadPrivilege TRUE indicates that the client has full
* permissions on the device, including read.
*/
BOOLEAN haveReadPrivilege;
//
// Memphis Blue Screen info
//
BLUESCREEN BlueScreenData;
BOOLEAN isSecureOpen;
ULONG SecureReadMode;
/*
* If a read fails, some clients reissue the read on the same thread.
* If this happens repeatedly, we can run out of stack space.
* So we keep track of the depth
*/
#define INSIDE_READCOMPLETE_MAX 4
ULONG insideReadCompleteCount;
#if DBG
BOOLEAN ListSpinLockTaken;
ULONG dbgNumReportsDroppedSinceLastRead;
ULONG Signature;
#endif
} HIDCLASS_FILE_EXTENSION;
#if DBG
#define HIDCLASS_FILE_EXTENSION_SIG 'efcH'
#endif
typedef struct {
#define ASYNC_COMPLETE_CONTEXT_SIG 'cnsA'
ULONG sig;
WORK_QUEUE_ITEM workItem;
PIRP irp;
PDEVICE_OBJECT devObj;
} ASYNC_COMPLETE_CONTEXT;
//
// HIDCLASS_REPORT is the structure we use to track a report returned from
// the minidriver.
//
typedef struct _HIDCLASS_REPORT {
//
// ListEntry queues this report onto a file extension.
//
LIST_ENTRY ListEntry;
ULONG reportLength;
//
// UnparsedReport is a data area for the unparsed report data as returned
// from the minidriver. The lengths of all input reports for a given
// class are the same, so we don't need to store the length in each
// report.
//
UCHAR UnparsedReport[];
} HIDCLASS_REPORT;
typedef struct _HIDCLASS_WORK_ITEM_DATA {
PIRP Irp;
PDO_EXTENSION *PdoExt;
PIO_WORKITEM Item;
BOOLEAN RemoteWakeState;
} HIDCLASS_WORK_ITEM_DATA, *PHIDCLASS_WORK_ITEM_DATA;
//
// Internal shared function prototypes
//
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath);
NTSTATUS HidpAddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject);
VOID HidpDriverUnload(IN struct _DRIVER_OBJECT *minidriverObject);
NTSTATUS HidpCallDriver(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp);
NTSTATUS HidpCallDriverSynchronous(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp);
NTSTATUS HidpCopyInputReportToUser(IN PHIDCLASS_FILE_EXTENSION fdoExtension, IN PUCHAR ReportData, IN OUT PULONG UserBufferLen, OUT PUCHAR UserBuffer);
NTSTATUS HidpCreateSymbolicLink(IN PDO_EXTENSION *pdoExtension, IN ULONG collectionNum, IN BOOLEAN Create, IN PDEVICE_OBJECT Pdo);
NTSTATUS HidpCreateClientPDOs(PHIDCLASS_DEVICE_EXTENSION hidClassExtension);
ULONG HidpSetMaxReportSize(IN FDO_EXTENSION *fdoExtension);
VOID EnqueueInterruptReport(PHIDCLASS_FILE_EXTENSION fileExtension, PHIDCLASS_REPORT report);
PHIDCLASS_REPORT DequeueInterruptReport(PHIDCLASS_FILE_EXTENSION fileExtension, LONG maxLen);
VOID HidpDestroyFileExtension(PHIDCLASS_COLLECTION collection, PHIDCLASS_FILE_EXTENSION FileExtension);
VOID HidpFlushReportQueue(IN PHIDCLASS_FILE_EXTENSION FileExtension);
NTSTATUS HidpGetCollectionDescriptor(IN FDO_EXTENSION *fdoExtension, IN ULONG collectionId, IN PVOID Buffer, IN OUT PULONG BufferSize);
NTSTATUS HidpGetCollectionInformation(IN FDO_EXTENSION *fdoExtension, IN ULONG collectionNumber, IN PVOID Buffer, IN OUT PULONG BufferSize);
NTSTATUS HidpGetDeviceDescriptor(FDO_EXTENSION *fdoExtension);
BOOLEAN HidpStartIdleTimeout(FDO_EXTENSION *fdoExt, BOOLEAN DeviceStart);
VOID HidpCancelIdleNotification(FDO_EXTENSION *fdoExt, BOOLEAN removing);
VOID HidpIdleTimeWorker(PDEVICE_OBJECT DeviceObject, PIO_WORKITEM Item);
VOID HidpIdleNotificationCallback(PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension);
NTSTATUS HidpRegisterDeviceForIdleDetection(PDEVICE_OBJECT DeviceObject, ULONG IdleTime, PULONG *);
VOID HidpSetDeviceBusy(FDO_EXTENSION *fdoExt);
NTSTATUS HidpCheckIdleState(PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension,PIRP Irp);
NTSTATUS HidpGetRawDeviceDescriptor(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, OUT PULONG RawDeviceDescriptorLength, OUT PUCHAR *RawDeviceDescriptor);
NTSTATUS HidpInitializePingPongIrps(FDO_EXTENSION *fdoExtension);
NTSTATUS HidpReallocPingPongIrps(FDO_EXTENSION *fdoExtension, ULONG newNumBufs);
NTSTATUS HidpIrpMajorPnpComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context);
NTSTATUS HidpMajorHandler(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS HidpParseAndBuildLinks(FDO_EXTENSION *fdoExtension);
NTSTATUS HidpFdoPowerCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context);
BOOLEAN EnqueueDriverExt(PHIDCLASS_DRIVER_EXTENSION driverExt);
PHIDCLASS_DRIVER_EXTENSION RefDriverExt(IN PDRIVER_OBJECT MinidriverObject);
PHIDCLASS_DRIVER_EXTENSION DerefDriverExt(IN PDRIVER_OBJECT MinidriverObject);
NTSTATUS HidpStartAllPingPongs(FDO_EXTENSION *fdoExtension);
ULONG HidiGetClassCollectionOrdinal(IN PHIDCLASS_COLLECTION ClassCollection);
PHIDP_COLLECTION_DESC HidiGetHidCollectionByClassCollection(IN PHIDCLASS_COLLECTION ClassCollection);
PHIDP_REPORT_IDS GetReportIdentifier(FDO_EXTENSION *fdoExtension, ULONG reportId);
PHIDP_COLLECTION_DESC GetCollectionDesc(FDO_EXTENSION *fdoExtension, ULONG collectionId);
PHIDCLASS_COLLECTION GetHidclassCollection(FDO_EXTENSION *fdoExtension, ULONG collectionId);
//NTSTATUS HidpGetSetFeature(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp, IN ULONG controlCode, OUT BOOLEAN *sentIrp);
NTSTATUS HidpGetSetReport(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp, IN ULONG controlCode, OUT BOOLEAN *sentIrp);
NTSTATUS HidpGetDeviceString(IN FDO_EXTENSION *fdoExt, IN OUT PIRP Irp, IN ULONG stringId, IN ULONG languageId);
NTSTATUS HidpGetPhysicalDescriptor(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorRead(IN PHIDCLASS_DEVICE_EXTENSION, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorCreate(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorWrite(IN PHIDCLASS_DEVICE_EXTENSION, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorPnp(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpPdoPnp(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpFdoPnp(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorPower(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorClose(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorDeviceControl(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorINTERNALDeviceControl(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorClose(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpIrpMajorDefault(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpInterruptReadComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context);
NTSTATUS HidpQueryDeviceRelations(IN PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, IN OUT PIRP Irp);
NTSTATUS HidpQueryCollectionCapabilities(PDO_EXTENSION *pdoExt, IN OUT PIRP Irp);
NTSTATUS HidpQueryIdForClientPdo(IN PHIDCLASS_DEVICE_EXTENSION hidClassExtension, IN OUT PIRP Irp);
NTSTATUS HidpQueryInterface(IN PHIDCLASS_DEVICE_EXTENSION hidClassExtension, IN OUT PIRP Irp);
PVOID MemDup(POOL_TYPE PoolType, PVOID dataPtr, ULONG length);
BOOLEAN AllClientPDOsInitialized(FDO_EXTENSION *fdoExtension, BOOLEAN initialized);
BOOLEAN AnyClientPDOsInitialized(FDO_EXTENSION *fdoExtension, BOOLEAN initialized);
NTSTATUS ClientPdoCompletion(PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, PIRP Irp);
BOOLEAN HidpDeleteDeviceObjects(FDO_EXTENSION *fdoExt);
VOID HidpCancelReadIrp(PDEVICE_OBJECT DeviceObject, PIRP Irp);
VOID CancelAllPingPongIrps(FDO_EXTENSION *fdoExt);
VOID HidpCleanUpFdo(FDO_EXTENSION *fdoExt);
NTSTATUS HidpRemoveDevice(FDO_EXTENSION *fdoExt, IN PIRP Irp);
VOID HidpRemoveCollection(FDO_EXTENSION *fdoExt, PDO_EXTENSION *pdoExt, IN PIRP Irp);
VOID HidpDestroyCollection(FDO_EXTENSION *fdoExt, PHIDCLASS_COLLECTION Collection);
VOID CollectionPowerRequestCompletion(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus);
VOID DevicePowerRequestCompletion(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus);
NTSTATUS HidpQueryCapsCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context);
NTSTATUS HidpQueryDeviceCapabilities(IN PDEVICE_OBJECT PdoDeviceObject, IN PDEVICE_CAPABILITIES DeviceCapabilities);
VOID DestroyPingPongs(FDO_EXTENSION *fdoExt);
VOID CheckReportPowerEvent(FDO_EXTENSION *fdoExt, PHIDCLASS_COLLECTION collection, PUCHAR report, ULONG reportLen);
BOOLEAN StartPollingLoop(FDO_EXTENSION *fdoExt, PHIDCLASS_COLLECTION hidCollection, BOOLEAN freshQueue);
VOID StopPollingLoop(PHIDCLASS_COLLECTION hidCollection, BOOLEAN flushQueue);
BOOLEAN ReadPolledDevice(PDO_EXTENSION *pdoExt, BOOLEAN isTimerDrivenRead);
VOID PolledReadCancelRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
VOID EnqueueFdoExt(FDO_EXTENSION *fdoExt);
VOID DequeueFdoExt(FDO_EXTENSION *fdoExt);
NTSTATUS AllocDeviceResources(FDO_EXTENSION *fdoExt);
VOID FreeDeviceResources(FDO_EXTENSION *fdoExt);
NTSTATUS AllocCollectionResources(FDO_EXTENSION *fdoExt, ULONG collectionNum);
VOID FreeCollectionResources(FDO_EXTENSION *fdoExt, ULONG collectionNum);
NTSTATUS InitializeCollection(FDO_EXTENSION *fdoExt, ULONG collectionIndex);
NTSTATUS HidpStartCollectionPDO(FDO_EXTENSION *fdoExt, PDO_EXTENSION *pdoExt, PIRP Irp);
NTSTATUS HidpStartDevice(PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, PIRP Irp);
PWCHAR SubstituteBusNames(PWCHAR oldIDs, FDO_EXTENSION *fdoExt, PDO_EXTENSION *pdoExt);
PWSTR BuildCompatibleID(PHIDCLASS_DEVICE_EXTENSION hidClassExtension);
PUNICODE_STRING MakeClientPDOName(PUNICODE_STRING fdoName, ULONG collectionId);
VOID HidpPingpongBackoffTimerDpc(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2);
BOOLEAN WStrCompareN(PWCHAR str1, PWCHAR str2, ULONG maxChars);
NTSTATUS SubmitWaitWakeIrp(PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension);
BOOLEAN HidpIsWaitWakePending(FDO_EXTENSION *fdoExt, BOOLEAN setIfNotPending);
NTSTATUS HidpWaitWakeComplete(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus);
NTSTATUS HidpGetIndexedString(IN FDO_EXTENSION *fdoExt, IN OUT PIRP Irp, IN ULONG stringIndex, IN ULONG languageId);
VOID CompleteAllPendingReadsForCollection(PHIDCLASS_COLLECTION Collection);
VOID CompleteAllPendingReadsForFileExtension(PHIDCLASS_COLLECTION Collection, PHIDCLASS_FILE_EXTENSION fileExtension);
VOID CompleteAllPendingReadsForDevice(FDO_EXTENSION *fdoExt);
BOOLEAN MyPrivilegeCheck(PIRP Irp);
NTSTATUS QueuePowerEventIrp(PHIDCLASS_COLLECTION hidCollection, PIRP Irp);
VOID PowerEventCancelRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS HidpPolledReadComplete(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context);
NTSTATUS HidpPolledReadComplete_TimerDriven(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context);
VOID CollectionWaitWakeIrpCancelRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
VOID CompleteAllCollectionWaitWakeIrps(FDO_EXTENSION *fdoExt, NTSTATUS status);
VOID PowerDelayedCancelRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS EnqueuePowerDelayedIrp(PHIDCLASS_DEVICE_EXTENSION HidDeviceExtension, PIRP Irp);
PIRP DequeuePowerDelayedIrp(FDO_EXTENSION *fdoExt);
ULONG DequeueAllPdoPowerDelayedIrps(PDO_EXTENSION *pdoExt, PLIST_ENTRY dequeue);
VOID ReadDeviceFlagsFromRegistry(FDO_EXTENSION *fdoExt, PDEVICE_OBJECT pdo);
LONG WStrNCmpI(PWCHAR s1, PWCHAR s2, ULONG n);
ULONG LAtoX(PWCHAR wHexString);
ULONG WStrNCpy(PWCHAR dest, PWCHAR src, ULONG n);
NTSTATUS OpenSubkey(OUT PHANDLE Handle, IN HANDLE BaseHandle, IN PUNICODE_STRING KeyName, IN ACCESS_MASK DesiredAccess);
void HidpNumberToString(PWCHAR String, USHORT Number, USHORT stringLen);
NTSTATUS GetHIDRawReportDescriptor(FDO_EXTENSION *fdoExt, PIRP irp, ULONG descriptorLen);
VOID WorkItemCallback_CompleteIrpAsynchronously(PVOID context);
NTSTATUS EnqueueInterruptReadIrp(PHIDCLASS_COLLECTION collection, PHIDCLASS_FILE_EXTENSION fileExtension, PIRP Irp);
PIRP DequeueInterruptReadIrp(PHIDCLASS_COLLECTION collection, PHIDCLASS_FILE_EXTENSION fileExtension);
NTSTATUS EnqueuePolledReadIrp(PHIDCLASS_COLLECTION collection, PIRP Irp);
PIRP DequeuePolledReadSystemIrp(PHIDCLASS_COLLECTION collection);
PIRP DequeuePolledReadIrp(PHIDCLASS_COLLECTION collection);
NTSTATUS HidpProcessInterruptReport(PHIDCLASS_COLLECTION collection, PHIDCLASS_FILE_EXTENSION FileExtension, PUCHAR Report, ULONG ReportLength, PIRP *irpToComplete);
VOID HidpFreePowerEventIrp(PHIDCLASS_COLLECTION Collection);
NTSTATUS HidpGetMsGenreDescriptor(IN FDO_EXTENSION *fdoExt, IN OUT PIRP Irp);
NTSTATUS DllUnload(VOID);
NTSTATUS DllInitialize (PUNICODE_STRING RegistryPath);
VOID HidpPowerUpPdos(IN PFDO_EXTENSION fdoExt);
NTSTATUS HidpDelayedPowerPoRequestComplete(IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus);
NTSTATUS HidpIrpMajorSystemControl(PHIDCLASS_DEVICE_EXTENSION DeviceObject, PIRP Irp);
NTSTATUS HidpSetWmiDataItem(PDEVICE_OBJECT DeviceObject, PIRP Irp, ULONG GuidIndex, ULONG InstanceIndex, ULONG DataItemId, ULONG BufferSize, PUCHAR Buffer);
NTSTATUS HidpSetWmiDataBlock(PDEVICE_OBJECT DeviceObject, PIRP Irp, ULONG GuidIndex, ULONG InstanceIndex, ULONG BufferSize, PUCHAR Buffer);
NTSTATUS HidpQueryWmiDataBlock( PDEVICE_OBJECT DeviceObject, PIRP Irp, ULONG GuidIndex, ULONG InstanceIndex, ULONG InstanceCount, OUT PULONG InstanceLengthArray, ULONG BufferAvail, PUCHAR Buffer);
NTSTATUS HidpQueryWmiRegInfo( PDEVICE_OBJECT DeviceObject, ULONG *RegFlags, PUNICODE_STRING InstanceName, PUNICODE_STRING *RegistryPath, PUNICODE_STRING MofResourceName, PDEVICE_OBJECT *Pdo);
BOOLEAN HidpCreateRemoteWakeIrp (PDO_EXTENSION *PdoExt);
void HidpCreateRemoteWakeIrpWorker (PDEVICE_OBJECT DeviceObject, PHIDCLASS_WORK_ITEM_DATA ItemData);
NTSTATUS HidpToggleRemoteWake(PDO_EXTENSION *PdoExt, BOOLEAN RemoteWakeState);
#if DBG
VOID InitFdoExtDebugInfo(PHIDCLASS_DEVICE_EXTENSION hidclassExt);
#endif
extern ULONG HidpNextHidNumber;
extern FDO_EXTENSION *allFdoExtensions;
extern KSPIN_LOCK allFdoExtensionsSpinLock;
PVOID
HidpGetSystemAddressForMdlSafe(PMDL MdlAddress);