mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1962 lines
59 KiB
1962 lines
59 KiB
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1993 - 1999
|
|
|
|
Module Name :
|
|
|
|
parport.h
|
|
|
|
Abstract:
|
|
|
|
Type definitions and data for the parallel port driver.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#ifndef _PARPORT_H_
|
|
#define _PARPORT_H_
|
|
|
|
#define arraysize(p) (sizeof(p)/sizeof((p)[0])) // From Walter Oney WDM book
|
|
|
|
// Used to keep track of the state of an IEEE negotiation, transfer, or termination
|
|
typedef struct _IEEE_STATE {
|
|
ULONG CurrentEvent; // IEEE 1284 event - see IEEE 1284-1994 spec
|
|
P1284_PHASE CurrentPhase; // see parallel.h for enum def - PHASE_UNKNOWN, ..., PHASE_INTERRUPT_HOST
|
|
BOOLEAN Connected; // are we currently negotiated into a 1284 mode?
|
|
BOOLEAN IsIeeeTerminateOk; // are we in a state where an IEEE Terminate is legal?
|
|
USHORT ProtocolFamily; // what protocol family are we currently using (if connected)
|
|
} IEEE_STATE, *PIEEE_STATE;
|
|
|
|
// should we use or ignore XFlag on termination event 24 when terminating NIBBLE mode for 1284 ID query?
|
|
typedef enum {
|
|
IgnoreXFlagOnEvent24,
|
|
UseXFlagOnEvent24
|
|
} XFlagOnEvent24;
|
|
|
|
// DVDF - 2000-08-16
|
|
// Used with IOCTL_INTERNAL_PARPORT_EXECUTE_TASK
|
|
typedef enum {
|
|
Select,
|
|
Deselect,
|
|
Write,
|
|
Read,
|
|
MaxTask
|
|
} ParportTask;
|
|
|
|
// Used with IOCTL_INTERNAL_PARPORT_EXECUTE_TASK
|
|
typedef struct _PARPORT_TASK {
|
|
ParportTask Task; // what type of request?
|
|
PCHAR Buffer; // where is the buffer to use?
|
|
ULONG BufferLength; // how big is the buffer?
|
|
ULONG RequestLength; // how many bytes of data is requested or supplied?
|
|
CHAR Requestor[8]; // diagnostic use only - suggest pdx->Location, e.g., "LPT2.4"
|
|
} PARPORT_TASK, *PPARPORT_TASK;
|
|
|
|
// handled by parport FDOs - execute a specified task
|
|
#define IOCTL_INTERNAL_PARPORT_EXECUTE_TASK CTL_CODE(FILE_DEVICE_PARALLEL_PORT, 64, METHOD_BUFFERED, FILE_ANY_ACCESS)
|
|
|
|
struct _PDO_EXTENSION;
|
|
typedef struct _PDO_EXTENSION * PPDO_EXTENSION;
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_READ_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_WRITE_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PDOT3_RESET_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef struct _DOT3DL_PCTL {
|
|
PPROTOCOL_READ_ROUTINE fnRead;
|
|
PPROTOCOL_WRITE_ROUTINE fnWrite;
|
|
PDOT3_RESET_ROUTINE fnReset;
|
|
P12843_DL_MODES DataLinkMode;
|
|
USHORT CurrentPID;
|
|
USHORT FwdSkipMask;
|
|
USHORT RevSkipMask;
|
|
UCHAR DataChannel;
|
|
UCHAR ResetChannel;
|
|
UCHAR ResetByteCount;
|
|
UCHAR ResetByte;
|
|
PKEVENT Event;
|
|
BOOLEAN bEventActive;
|
|
} DOT3DL_PCTL, *PDOT3DL_PCTL;
|
|
|
|
//
|
|
// If we can't use our preferred \Device\ParallelN number due to name collision,
|
|
// then start with N == PAR_CLASSNAME_OFFSET and increment until we are successful
|
|
//
|
|
#define PAR_CLASSNAME_OFFSET 8
|
|
|
|
//
|
|
// For pnp id strings
|
|
//
|
|
#define MAX_ID_SIZE 256
|
|
|
|
// used to construct IEEE 1284.3 "Dot" name suffixes
|
|
// table lookup for integer to WCHAR conversion
|
|
#define PAR_UNICODE_PERIOD L'.'
|
|
#define PAR_UNICODE_COLON L':'
|
|
|
|
|
|
//#define PAR_REV_MODE_SKIP_MASK (CHANNEL_NIBBLE | BYTE_BIDIR | EPP_ANY)
|
|
#define PAR_REV_MODE_SKIP_MASK (CHANNEL_NIBBLE | BYTE_BIDIR | EPP_ANY | ECP_ANY)
|
|
#define PAR_FWD_MODE_SKIP_MASK (EPP_ANY | BOUNDED_ECP | ECP_HW_NOIRQ | ECP_HW_IRQ)
|
|
//#define PAR_FWD_MODE_SKIP_MASK (EPP_ANY)
|
|
#define PAR_MAX_CHANNEL 127
|
|
#define PAR_COMPATIBILITY_RESET 300
|
|
|
|
|
|
|
|
#define PptSetFlags( FlagsVariable, FlagsToSet ) { (FlagsVariable) |= (FlagsToSet); }
|
|
#define PptClearFlags( FlagsVariable, FlagsToClear ) { (FlagsVariable) &= ~(FlagsToClear); }
|
|
|
|
// convert timeout in Milliseconds to relative timeout in 100ns units
|
|
// suitable as parameter 5 to KeWaitForSingleObject(..., TimeOut)
|
|
#define PPT_SET_RELATIVE_TIMEOUT_IN_MILLISECONDS(VARIABLE, VALUE) (VARIABLE).QuadPart = -( (LONGLONG) (VALUE)*10*1000 )
|
|
|
|
#define MAX_PNP_IRP_MN_HANDLED IRP_MN_QUERY_LEGACY_BUS_INFORMATION
|
|
|
|
extern ULONG PptDebugLevel;
|
|
extern ULONG PptBreakOn;
|
|
extern UNICODE_STRING RegistryPath; // copy of the registry path passed to DriverEntry()
|
|
|
|
extern UCHAR PptDot3Retries; // variable to know how many times to try a select or
|
|
// deselect for 1284.3 if we do not succeed.
|
|
|
|
typedef enum _DevType {
|
|
DevTypeFdo = 1,
|
|
DevTypePdo = 2,
|
|
} DevType, *PDevType;
|
|
|
|
typedef enum _PdoType {
|
|
PdoTypeRawPort = 1,
|
|
PdoTypeEndOfChain = 2,
|
|
PdoTypeDaisyChain = 4,
|
|
PdoTypeLegacyZip = 8
|
|
} PdoType, *PPdoType;
|
|
|
|
extern const PHYSICAL_ADDRESS PhysicalZero;
|
|
|
|
#define PARPORT_TAG (ULONG) 'PraP'
|
|
|
|
|
|
#ifdef POOL_TAGGING
|
|
#ifdef ExAllocatePool
|
|
#undef ExAllocatePool
|
|
#endif
|
|
#define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,PARPORT_TAG)
|
|
#endif
|
|
|
|
|
|
//
|
|
// used for FilterResourceMethod in processing PnP IRP_MN_FILTER_RESOURCE_REQUIREMENTS
|
|
//
|
|
#define PPT_TRY_USE_NO_IRQ 0 // if alternatives exist that don't require an IRQ then
|
|
// delete those alternatives that do, otherwise do nothing
|
|
#define PPT_FORCE_USE_NO_IRQ 1 // try previous method - if it fails (i.e., all alternatives
|
|
// require resources), then nuke IRQ resource descriptors
|
|
// in all alternatives
|
|
#define PPT_ACCEPT_IRQ 2 // don't do any resource filtering - accept resources that
|
|
// we are given
|
|
|
|
|
|
//
|
|
// Keep track of GET and RELEASE port info.
|
|
//
|
|
extern LONG PortInfoReferenceCount;
|
|
extern PFAST_MUTEX PortInfoMutex;
|
|
|
|
//
|
|
// DeviceStateFlags
|
|
//
|
|
#define PAR_DEVICE_PAUSED ((ULONG)0x00000010) // stop-pending, stopped, or remove-pending states
|
|
#define PAR_DEVICE_PORT_REMOVE_PENDING ((ULONG)0x00000200) // our ParPort is in a Remove Pending State
|
|
|
|
//
|
|
// extension->PnpState - define the current PnP state of the device
|
|
//
|
|
#define PPT_DEVICE_STARTED ((ULONG)0x00000001) // Device has succeeded START
|
|
#define PPT_DEVICE_DELETED ((ULONG)0x00000002) // IoDeleteDevice has been called
|
|
#define PPT_DEVICE_STOP_PENDING ((ULONG)0x00000010) // Device has succeeded QUERY_STOP, waiting for STOP or CANCEL
|
|
#define PPT_DEVICE_STOPPED ((ULONG)0x00000020) // Device has received STOP
|
|
#define PPT_DEVICE_DELETE_PENDING ((ULONG)0x00000040) // we have started the process of deleting device object
|
|
#define PPT_DEVICE_HARDWARE_GONE ((ULONG)0x00000080) // our hardware is gone
|
|
#define PPT_DEVICE_REMOVE_PENDING ((ULONG)0x00000100) // Device succeeded QUERY_REMOVE, waiting for REMOVE or CANCEL
|
|
#define PPT_DEVICE_REMOVED ((ULONG)0x00000200) // Device has received REMOVE
|
|
#define PPT_DEVICE_SURPRISE_REMOVED ((ULONG)0x00001000) // Device has received SURPRISE_REMOVAL
|
|
#define PPT_DEVICE_PAUSED ((ULONG)0x00010000) // stop-pending, stopped, or remove-pending - hold requests
|
|
|
|
//
|
|
// IEEE 1284 constants (Protocol Families)
|
|
//
|
|
#define FAMILY_NONE 0x0
|
|
#define FAMILY_REVERSE_NIBBLE 0x1
|
|
#define FAMILY_REVERSE_BYTE 0x2
|
|
#define FAMILY_ECP 0x3
|
|
#define FAMILY_EPP 0x4
|
|
#define FAMILY_BECP 0x5
|
|
#define FAMILY_MAX FAMILY_BECP
|
|
|
|
|
|
typedef struct _IRPQUEUE_CONTEXT {
|
|
LIST_ENTRY irpQueue;
|
|
KSPIN_LOCK irpQueueSpinLock;
|
|
} IRPQUEUE_CONTEXT, *PIRPQUEUE_CONTEXT;
|
|
|
|
typedef struct _COMMON_EXTENSION {
|
|
ULONG Signature1; // Used to increase our confidence that this is a ParPort extension
|
|
enum _DevType DevType; // distinguish an FDO_EXTENSION from a PDO_EXTENSION
|
|
PCHAR Location; // LPTx or LPTx.y location for PDO (symlink name less the \DosDevices prefix)
|
|
// LPTxF for FDO
|
|
PDEVICE_OBJECT DeviceObject; // back pointer to our DEVICE_OBJECT
|
|
ULONG PnpState; // Device State - See Device State Flags: PPT_DEVICE_... above
|
|
IO_REMOVE_LOCK RemoveLock; // Used to prevent PnP from removing us while requests are pending
|
|
LONG OpenCloseRefCount; // keep track of the number of handles open to our device
|
|
UNICODE_STRING DeviceInterface; // SymbolicLinkName returned from IoRegisterDeviceInterface
|
|
BOOLEAN DeviceInterfaceState; // Did we last set the DeviceInterface to True or False?
|
|
BOOLEAN TimeToTerminateThread;// TRUE == worker thread should kill itself via PsTerminateSystemThread()
|
|
PVOID ThreadObjectPointer; // pointer to a worker thread for this Device
|
|
} COMMON_EXTENSION, *PCOMMON_EXTENSION, *PCE;
|
|
|
|
|
|
//
|
|
// Fdo Device Extension
|
|
//
|
|
typedef struct _FDO_EXTENSION {
|
|
|
|
COMMON_EXTENSION;
|
|
|
|
//
|
|
// Devices that we have enumerated
|
|
//
|
|
PDEVICE_OBJECT RawPortPdo; // LPTx - legacy "Raw Port" interface
|
|
PDEVICE_OBJECT DaisyChainPdo[4]; // LPTx.0 -- LPTx.3 - IEEE 1284.3 daisy chain devices
|
|
PDEVICE_OBJECT EndOfChainPdo; // LPTx.4 - end-of-chain devices
|
|
PDEVICE_OBJECT LegacyZipPdo; // LPTx.5 - original (non-1284.3) Iomega Zip drive
|
|
|
|
IEEE_STATE IeeeState;
|
|
|
|
//
|
|
// DisableEndOfChainBusRescan - if TRUE then do NOT rescan bus for change in End Of Chain (LPTx.4)
|
|
// device in response to PnP IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations,
|
|
// simply report the LPTx.4 device that we found on the previous bus rescan.
|
|
// - if we did not have an End Of Chain device on the previous rescan then this
|
|
// flag is ignored.
|
|
//
|
|
BOOLEAN DisableEndOfChainBusRescan;
|
|
|
|
//
|
|
// Points to the driver object that contains this instance of parport.
|
|
//
|
|
PDRIVER_OBJECT DriverObject;
|
|
|
|
//
|
|
// Points to the PDO
|
|
//
|
|
PDEVICE_OBJECT PhysicalDeviceObject;
|
|
|
|
//
|
|
// Points to our parent
|
|
//
|
|
PDEVICE_OBJECT ParentDeviceObject;
|
|
|
|
//
|
|
// Counter is incremented by the "polling for printers" thread on
|
|
// each failed attempt at reading the IEEE 1284 Device ID from the
|
|
// device. When the counter hits a defined threshold the polling
|
|
// thread considers the error unrecoverable and stops polling
|
|
//
|
|
ULONG PollingFailureCounter;
|
|
|
|
// list head for list of PDOs to delete on Driver Unload
|
|
LIST_ENTRY DevDeletionListHead;
|
|
|
|
//
|
|
// Queue of ALLOCATE & SELECT irps waiting to be processed. Access with cancel spin lock.
|
|
//
|
|
LIST_ENTRY WorkQueue;
|
|
|
|
// Queue Irps while waiting to be processed
|
|
IRPQUEUE_CONTEXT IrpQueueContext;
|
|
|
|
//
|
|
// The number of irps in the queue where -1 represents
|
|
// a free port, 0 represents an allocated port with
|
|
// zero waiters, 1 represents an allocated port with
|
|
// 1 waiter, etc...
|
|
//
|
|
// This variable must be accessed with the cancel spin
|
|
// lock or at interrupt level whenever interrupts are
|
|
// being used.
|
|
//
|
|
LONG WorkQueueCount;
|
|
|
|
//
|
|
// These structures hold the port address and range for the parallel port.
|
|
//
|
|
PARALLEL_PORT_INFORMATION PortInfo;
|
|
PARALLEL_PNP_INFORMATION PnpInfo;
|
|
|
|
//
|
|
// Information about the interrupt so that we
|
|
// can connect to it when we have a client that
|
|
// uses the interrupt.
|
|
//
|
|
ULONG AddressSpace;
|
|
ULONG EcpAddressSpace;
|
|
|
|
INTERFACE_TYPE InterfaceType;
|
|
ULONG BusNumber;
|
|
|
|
BOOLEAN FoundInterrupt;
|
|
KIRQL InterruptLevel;
|
|
ULONG InterruptVector;
|
|
KAFFINITY InterruptAffinity;
|
|
KINTERRUPT_MODE InterruptMode;
|
|
|
|
|
|
//
|
|
// This list contains all of the interrupt service
|
|
// routines registered by class drivers. All access
|
|
// to this list should be done at interrupt level.
|
|
//
|
|
// This list also contains all of the deferred port check
|
|
// routines. These routines are called whenever
|
|
// the port is freed if there are no IRPs queued for
|
|
// the port. Access this list only at interrupt level.
|
|
//
|
|
LIST_ENTRY IsrList;
|
|
|
|
//
|
|
// The parallel port interrupt object.
|
|
//
|
|
PKINTERRUPT InterruptObject;
|
|
|
|
//
|
|
// Keep a reference count for the interrupt object.
|
|
// This count should be referenced with the cancel
|
|
// spin lock.
|
|
//
|
|
ULONG InterruptRefCount;
|
|
|
|
//
|
|
// DPC for freeing the port from the interrupt routine.
|
|
//
|
|
KDPC FreePortDpc;
|
|
|
|
//
|
|
// Points to workitem for freeing the port
|
|
//
|
|
PIO_WORKITEM FreePortWorkItem;
|
|
|
|
//
|
|
// Set at initialization to indicate that on the current
|
|
// architecture we need to unmap the base register address
|
|
// when we unload the driver.
|
|
//
|
|
BOOLEAN UnMapRegisters;
|
|
|
|
//
|
|
// Flags for ECP and EPP detection and changing of the modes
|
|
//
|
|
BOOLEAN NationalChecked;
|
|
BOOLEAN NationalChipFound;
|
|
BOOLEAN FilterMode;
|
|
UCHAR EcrPortData;
|
|
|
|
//
|
|
// Structure that hold information from the Chip Filter Driver
|
|
//
|
|
PARALLEL_PARCHIP_INFO ChipInfo;
|
|
|
|
UNICODE_STRING DeviceName;
|
|
|
|
//
|
|
// Current Device Power State
|
|
//
|
|
DEVICE_POWER_STATE DeviceState;
|
|
SYSTEM_POWER_STATE SystemState;
|
|
|
|
FAST_MUTEX ExtensionFastMutex;
|
|
FAST_MUTEX OpenCloseMutex;
|
|
|
|
KEVENT FdoThreadEvent; // polling for printers thread waits w/timeout on this event
|
|
|
|
WMILIB_CONTEXT WmiLibContext;
|
|
PARPORT_WMI_ALLOC_FREE_COUNTS WmiPortAllocFreeCounts;
|
|
|
|
BOOLEAN CheckedForGenericEpp; // did we check for Generic (via the ECR) EPP capability?
|
|
BOOLEAN FdoWaitingOnPort;
|
|
BOOLEAN spare[2];
|
|
|
|
// Used to increase our confidence that this is a ParPort extension
|
|
ULONG Signature2;
|
|
|
|
} FDO_EXTENSION, *PFDO_EXTENSION;
|
|
|
|
typedef struct _PDO_EXTENSION {
|
|
|
|
COMMON_EXTENSION;
|
|
|
|
ULONG DeviceStateFlags; // Device State - See Device State Flags above
|
|
|
|
ULONG DeviceType; // - deprecated, use DevType in COMMON_EXTENSION - PAR_DEVTYPE_FDO=0x1, PODO=0x2, or PDO=0x4
|
|
|
|
enum _PdoType PdoType;
|
|
|
|
PDEVICE_OBJECT Fdo; // Points to our FDO (bus driver/parent device)
|
|
|
|
PCHAR Mfg; // MFG field from device's IEEE 1284 ID string
|
|
PCHAR Mdl; // MDL field from device's IEEE 1284 ID string
|
|
PCHAR Cid; // CID (Compatible ID) field from device's IEEE 1284 ID string
|
|
PWSTR PdoName; // name used in call to IoCreateDevice
|
|
PWSTR SymLinkName; // name used in call to IoCreateUnprotectedSymbolicLink
|
|
|
|
LIST_ENTRY DevDeletionList; // used by driver to create list of PDOs to delete on Driver Unload
|
|
|
|
// UCHAR DaisyChainId; // 0..3 if PdoTypeDaisyChain, ignored otherwise
|
|
|
|
UCHAR Ieee1284_3DeviceId; // PDO - 0..3 is 1284.3 Daisy Chain device, 4 is End-Of-Chain Device, 5 is Legacy Zip
|
|
BOOLEAN IsPdo; // TRUE == this is either a PODO or a PDO - use DeviceIdString[0] to distinguish
|
|
BOOLEAN EndOfChain; // PODO - TRUE==NOT a .3 daisy chain dev - deprecated, use Ieee1284_3DeviceId==4 instead
|
|
BOOLEAN PodoRegForWMI; // has this PODO registered for WMI callbacks?
|
|
|
|
PDEVICE_OBJECT ParClassFdo; // P[O]DO - points to the ParClass FDO
|
|
|
|
PDEVICE_OBJECT ParClassPdo; // FDO - points to first P[O]DO in list of ParClass created PODOs and PDOs
|
|
|
|
PDEVICE_OBJECT Next; // P[O]DO - points to the next DO in the list of ParClass ejected P[O]DOs
|
|
|
|
PDEVICE_OBJECT PortDeviceObject; // P[O]DO - points to the associated ParPort device object
|
|
|
|
PFILE_OBJECT PortDeviceFileObject;// P[O]DO - referenced pointer to a FILE created against PortDeviceObject
|
|
|
|
UNICODE_STRING PortSymbolicLinkName;// P[O]DO - Sym link name of the assoc ParPort device - used to open a FILE
|
|
|
|
PDEVICE_OBJECT PhysicalDeviceObject;// FDO - The PDO passed to ParPnPAddDevice
|
|
|
|
PDEVICE_OBJECT ParentDeviceObject; // FDO - parent DO returned by IoAttachDeviceToDeviceStack
|
|
PIRP CurrentOpIrp; // IRP that our thread is currently processing
|
|
PVOID NotificationHandle; // PlugPlay Notification Handle
|
|
|
|
ULONG Event22Delay; // time in microseconds to delay prior to setting event 22 in IEEE 1284 Termination
|
|
|
|
ULONG TimerStart; // initial value used for countdown when starting an operation
|
|
|
|
BOOLEAN CreatedSymbolicLink; // P[O]DO - did we create a Symbolic Link for this device?
|
|
|
|
BOOLEAN UsePIWriteLoop; // P[O]DO - do we want to use processor independant write loop?
|
|
|
|
BOOLEAN ParPortDeviceGone; // Is our ParPort device object gone, possibly surprise removed?
|
|
|
|
BOOLEAN RegForPptRemovalRelations; // Are we registered for ParPort removal relations?
|
|
|
|
UCHAR Ieee1284Flags; // is device Stl older 1284.3 spec device?
|
|
|
|
BOOLEAN DeleteOnRemoveOk; // True means that it is OK to call IoDeleteDevice during IRP_MN_REMOVE_DEVICE processing
|
|
// - FDO sets this to True during QDR/BusRelations processing if it detects that the hardware
|
|
// is no longer present.
|
|
|
|
USHORT IdxForwardProtocol; // see afpForward[] in ieee1284.c
|
|
USHORT IdxReverseProtocol; // see arpReverse[] in ieee1284.c
|
|
ULONG CurrentEvent; // IEEE 1284 event - see IEEE 1284-1994 spec
|
|
P1284_PHASE CurrentPhase; // see parallel.h for enum def - PHASE_UNKNOWN, ..., PHASE_INTERRUPT_HOST
|
|
P1284_HW_MODE PortHWMode; // see parallel.h for enum def - HW_MODE_COMPATIBILITY, ..., HW_MODE_CONFIGURATION
|
|
|
|
FAST_MUTEX OpenCloseMutex; // protect manipulation of OpenCloseRefCount
|
|
|
|
FAST_MUTEX DevObjListMutex; // protect manipulation of list of ParClass ejected DOs
|
|
|
|
LIST_ENTRY WorkQueue; // Queue of irps waiting to be processed.
|
|
|
|
KSEMAPHORE RequestSemaphore;// dispatch routines use this to tell device worker thread that there is work to do
|
|
|
|
//
|
|
// PARALLEL_PORT_INFORMATION returned by IOCTL_INTERNAL_GET_PARALLEL_PORT_INFO
|
|
//
|
|
PHYSICAL_ADDRESS OriginalController;
|
|
PUCHAR Controller;
|
|
PUCHAR EcrController;
|
|
ULONG SpanOfController;
|
|
PPARALLEL_TRY_ALLOCATE_ROUTINE TryAllocatePort; // nonblocking callback to allocate ParPort device
|
|
PPARALLEL_FREE_ROUTINE FreePort; // callback to free ParPort device
|
|
PPARALLEL_QUERY_WAITERS_ROUTINE QueryNumWaiters; // callback to query number of waiters in port allocation queue
|
|
PVOID PortContext; // context for callbacks to ParPort
|
|
|
|
//
|
|
// subset of PARALLEL_PNP_INFORMATION returned by IOCTL_INTERNAL_GET_PARALLEL_PNP_INFO
|
|
//
|
|
ULONG HardwareCapabilities;
|
|
PPARALLEL_SET_CHIP_MODE TrySetChipMode;
|
|
PPARALLEL_CLEAR_CHIP_MODE ClearChipMode;
|
|
PPARALLEL_TRY_SELECT_ROUTINE TrySelectDevice;
|
|
PPARALLEL_DESELECT_ROUTINE DeselectDevice;
|
|
ULONG FifoDepth;
|
|
ULONG FifoWidth;
|
|
|
|
BOOLEAN bAllocated; // have we allocated associated ParPort device?
|
|
// Note: during some PnP processing we may have the port
|
|
// for a short duration without setting this value to TRUE
|
|
|
|
ULONG BusyDelay; // number of microseconds to wait after strobing a byte before checking the BUSY line.
|
|
|
|
BOOLEAN BusyDelayDetermined;// Indicates if the BusyDelay parameter has been computed yet.
|
|
|
|
PWORK_QUEUE_ITEM DeferredWorkItem; // Holds the work item used to defer printer initialization
|
|
|
|
// If the registry entry by the same name is set, run the parallel
|
|
// thread at the priority we used for NT 3.5 - this solves some
|
|
// cases where a dos app spinning for input in the foreground is
|
|
// starving the parallel thread
|
|
BOOLEAN UseNT35Priority;
|
|
|
|
ULONG InitializationTimeout;// timeout in seconds to wait for device to respond to an initialization request
|
|
// - default == 15 seconds
|
|
// - value overridden by registry entry of same name
|
|
// - we will spin for max amount if no device attached
|
|
|
|
LARGE_INTEGER AbsoluteOneSecond;// constants that are cheaper to put here rather
|
|
LARGE_INTEGER OneSecond; // than in bss
|
|
|
|
//
|
|
// IEEE 1284 Mode support
|
|
//
|
|
PPROTOCOL_READ_ROUTINE fnRead; // Current pointer to a valid read funtion
|
|
PPROTOCOL_WRITE_ROUTINE fnWrite; // Current pointer to a valid write Funtion
|
|
BOOLEAN Connected; // are we currently negotiated into a 1284 mode?
|
|
BOOLEAN AllocatedByLockPort; // are we currently allocated via IOCTL_INTERNAL_LOCK_PORT?
|
|
USHORT spare4[2];
|
|
LARGE_INTEGER IdleTimeout; // how long do we hold the port on the caller's behalf following an operation?
|
|
USHORT ProtocolData[FAMILY_MAX];
|
|
UCHAR ForwardInterfaceAddress;
|
|
UCHAR ReverseInterfaceAddress;
|
|
BOOLEAN SetForwardAddress;
|
|
BOOLEAN SetReverseAddress;
|
|
FAST_MUTEX LockPortMutex;
|
|
|
|
DEVICE_POWER_STATE DeviceState;// Current Device Power State
|
|
SYSTEM_POWER_STATE SystemState;// Current System Power State
|
|
|
|
ULONG spare2;
|
|
BOOLEAN bShadowBuffer;
|
|
Queue ShadowBuffer;
|
|
ULONG spare3;
|
|
BOOLEAN bSynchWrites; // TRUE if ECP HW writes should be synchronous
|
|
BOOLEAN bFirstByteTimeout; // TRUE if bus just reversed, means give the
|
|
// device some time to respond with some data
|
|
BOOLEAN bIsHostRecoverSupported; // Set via IOCTL_PAR_ECP_HOST_RECOVERY.
|
|
// HostRecovery will not be utilized unless this bit is set
|
|
KEVENT PauseEvent; // PnP dispatch routine uses this to pause worker thread during
|
|
// during QUERY_STOP, STOP, and QUERY_REMOVE states
|
|
|
|
USHORT ProtocolModesSupported;
|
|
USHORT BadProtocolModes;
|
|
|
|
PARALLEL_SAFETY ModeSafety;
|
|
BOOLEAN IsIeeeTerminateOk;
|
|
DOT3DL_PCTL P12843DL;
|
|
|
|
// WMI
|
|
PARALLEL_WMI_LOG_INFO log;
|
|
WMILIB_CONTEXT WmiLibContext;
|
|
LONG WmiRegistrationCount; // number of times this device has registered with WMI
|
|
|
|
// PnP Query ID results
|
|
UCHAR DeviceIdString[MAX_ID_SIZE]; // IEEE 1284 DeviceID string massaged/checksum'd to match INF form
|
|
UCHAR DeviceDescription[MAX_ID_SIZE]; // "Manufacturer<SPACE>Model" from IEEE 1284 DeviceID string
|
|
|
|
ULONG dummy; // dummy word to force RemoveLock to QuadWord alignment
|
|
PVOID HwProfileChangeNotificationHandle;
|
|
ULONG Signature2; // keep this the last member in extension
|
|
} PDO_EXTENSION, *PPDO_EXTENSION;
|
|
|
|
typedef struct _SYNCHRONIZED_COUNT_CONTEXT {
|
|
PLONG Count;
|
|
LONG NewCount;
|
|
} SYNCHRONIZED_COUNT_CONTEXT, *PSYNCHRONIZED_COUNT_CONTEXT;
|
|
|
|
typedef struct _SYNCHRONIZED_LIST_CONTEXT {
|
|
PLIST_ENTRY List;
|
|
PLIST_ENTRY NewEntry;
|
|
} SYNCHRONIZED_LIST_CONTEXT, *PSYNCHRONIZED_LIST_CONTEXT;
|
|
|
|
typedef struct _SYNCHRONIZED_DISCONNECT_CONTEXT {
|
|
PFDO_EXTENSION Extension;
|
|
PPARALLEL_INTERRUPT_SERVICE_ROUTINE IsrInfo;
|
|
} SYNCHRONIZED_DISCONNECT_CONTEXT, *PSYNCHRONIZED_DISCONNECT_CONTEXT;
|
|
|
|
typedef struct _ISR_LIST_ENTRY {
|
|
LIST_ENTRY ListEntry;
|
|
PKSERVICE_ROUTINE ServiceRoutine;
|
|
PVOID ServiceContext;
|
|
PPARALLEL_DEFERRED_ROUTINE DeferredPortCheckRoutine;
|
|
PVOID CheckContext;
|
|
} ISR_LIST_ENTRY, *PISR_LIST_ENTRY;
|
|
|
|
typedef struct _REMOVAL_RELATIONS_LIST_ENTRY {
|
|
LIST_ENTRY ListEntry;
|
|
PDEVICE_OBJECT DeviceObject;
|
|
ULONG Flags;
|
|
UNICODE_STRING DeviceName;
|
|
} REMOVAL_RELATIONS_LIST_ENTRY, *PREMOVAL_RELATIONS_LIST_ENTRY;
|
|
|
|
|
|
// former ecp.h follows:
|
|
|
|
#define DEFAULT_ECP_CHANNEL 0
|
|
|
|
#define ParTestEcpWrite(X) \
|
|
(X->CurrentPhase != PHASE_FORWARD_IDLE && X->CurrentPhase != PHASE_FORWARD_XFER) \
|
|
? STATUS_IO_DEVICE_ERROR : STATUS_SUCCESS
|
|
|
|
// ==================================================================
|
|
// The following RECOVER codes are used for Hewlett-Packard devices.
|
|
// Do not remove any of the error codes. These recover codes are
|
|
// used to quickly get the host and periph back to a known state.
|
|
// When using a recover code, add a comment where it is used at...
|
|
#define RECOVER_0 0 // Reserved - not used anywhere
|
|
#define RECOVER_1 1 // ECP_Terminate
|
|
#define RECOVER_2 2 // SLP_SetupPhase init
|
|
#define RECOVER_3 3 // SLP_FTP init DCR
|
|
#define RECOVER_4 4 // SLP_FTP init DSR
|
|
#define RECOVER_5 5 // SLP_FTP data xfer DCR
|
|
#define RECOVER_6 6 // SLP_FRP init DCR
|
|
#define RECOVER_7 7 // SLP_FRP init DSR
|
|
#define RECOVER_8 8 // SLP_FRP state 38 DCR
|
|
#define RECOVER_9 9 // SLP_FRP state 39 DCR
|
|
#define RECOVER_10 10 // SLP_FRP state 40 DSR
|
|
#define RECOVER_11 11 // SLP_RTP init DCR
|
|
#define RECOVER_12 12 // SLP_RTP init DSR
|
|
#define RECOVER_13 13 // SLP_RTP state 43 DCR
|
|
#define RECOVER_14 14 // SLP_RFP init DCR
|
|
#define RECOVER_15 15 // SLP_RFP init DSR
|
|
#define RECOVER_16 16 // SLP_RFP state 47- DCR
|
|
#define RECOVER_17 17 // SLP_RFP state 47 DCR
|
|
#define RECOVER_18 18 // SLP_RFP state 48 DSR
|
|
#define RECOVER_19 19 // SLP_RFP state 49 DSR
|
|
#define RECOVER_20 20 // ZIP_EmptyFifo DCR
|
|
#define RECOVER_21 21 // ZIP_FTP init DCR
|
|
#define RECOVER_22 22 // ZIP_FTP init DSR
|
|
#define RECOVER_23 23 // ZIP_FTP data xfer DCR
|
|
#define RECOVER_24 24 // ZIP_FRP init DSR
|
|
#define RECOVER_25 25 // ZIP_FRP init DCR
|
|
#define RECOVER_26 26 // ZIP_FRP state 38 DCR
|
|
#define RECOVER_27 27 // ZIP_FRP state 39 DCR
|
|
#define RECOVER_28 28 // ZIP_FRP state 40 DSR
|
|
#define RECOVER_29 29 // ZIP_FRP state 41 DCR
|
|
#define RECOVER_30 30 // ZIP_RTP init DSR
|
|
#define RECOVER_31 31 // ZIP_RTP init DCR
|
|
#define RECOVER_32 32 // ZIP_RFP init DSR
|
|
#define RECOVER_33 33 // ZIP_RFP init DCR
|
|
#define RECOVER_34 34 // ZIP_RFP state 47- DCR
|
|
#define RECOVER_35 35 // ZIP_RFP state 47 DCR
|
|
#define RECOVER_36 36 // ZIP_RFP state 48 DSR
|
|
#define RECOVER_37 37 // ZIP_RFP state 49 DSR
|
|
#define RECOVER_38 38 // ZIP_RFP state 49+ DCR
|
|
#define RECOVER_39 39 // Slippy_Terminate
|
|
#define RECOVER_40 40 // ZIP_SCA init DCR
|
|
#define RECOVER_41 41 // ZIP_SCA init DSR
|
|
#define RECOVER_42 42 // SLP_SCA init DCR
|
|
#define RECOVER_43 43 // SLP_SCA init DSR
|
|
#define RECOVER_44 44 // ZIP_SP init DCR
|
|
#define RECOVER_45 45 // SIP_FRP init DSR
|
|
#define RECOVER_46 46 // SIP_FRP init DCR
|
|
#define RECOVER_47 47 // SIP_FRP state 38 DCR
|
|
#define RECOVER_48 48 // SIP_FRP state 39 DCR
|
|
#define RECOVER_49 49 // SIP_FRP state 40 DSR
|
|
#define RECOVER_50 50 // SIP_RTP init DCR
|
|
#define RECOVER_51 51 // SIP_RFP init DSR
|
|
#define RECOVER_52 52 // SIP_RFP state 43 DCR
|
|
|
|
// former ecp.h preceeds
|
|
|
|
// former hwecp.h follows
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Printer status constants. Seem to only be used by hwecp
|
|
//--------------------------------------------------------------------------
|
|
#define CHKPRNOK 0xDF // DSR value indicating printer ok.
|
|
#define CHKPRNOFF1 0x87 // DSR value indicating printer off.
|
|
#define CHKPRNOFF2 0x4F // DSR value indicating printer off.
|
|
#define CHKNOCABLE 0x7F // DSR value indicating no cable.
|
|
#define CHKPRNOFLIN 0xCF // DSR value indicating printer offline.
|
|
#define CHKNOPAPER 0xEF // DSR value indicating out of paper.
|
|
#define CHKPAPERJAM 0xC7 // DSR value indicating paper jam.
|
|
|
|
// former hwecp.h preceeds
|
|
|
|
// former parclass.h follows
|
|
|
|
#define REQUEST_DEVICE_ID TRUE
|
|
#define HAVE_PORT_KEEP_PORT TRUE
|
|
|
|
// enable scans for Legacy Zip?
|
|
extern ULONG ParEnableLegacyZip;
|
|
|
|
#define PAR_LGZIP_PSEUDO_1284_ID_STRING "MFG:IMG;CMD:;MDL:VP0;CLS:SCSIADAPTER;DES:IOMEGA PARALLEL PORT"
|
|
extern PCHAR ParLegacyZipPseudoId;
|
|
|
|
#define USE_PAR3QUERYDEVICEID 1
|
|
|
|
extern LARGE_INTEGER AcquirePortTimeout; // timeout for IOCTL_INTERNAL_PARALLEL_PORT_ALLOCATE
|
|
extern ULONG g_NumPorts; // used to generate N in \Device\ParallelN ClassName
|
|
extern UNICODE_STRING RegistryPath; // copy of the registry path passed to DriverEntry()
|
|
|
|
extern ULONG DumpDevExtTable;
|
|
|
|
// Driver Globals
|
|
extern ULONG SppNoRaiseIrql; // 0 == original raise IRQL behavior in SPP
|
|
// !0 == new behavior - disable raise IRQL
|
|
// and insert some KeDelayExecutionThread
|
|
// calls while waiting for peripheral response
|
|
|
|
extern ULONG DefaultModes; // Upper USHORT is Reverse Default Mode, Lower is Forward Default Mode
|
|
// if == 0, or invalid, then use default of Nibble/Centronics
|
|
|
|
extern ULONG WarmPollPeriod; // time between polls for printers (in seconds)
|
|
|
|
extern BOOLEAN PowerStateIsAC;
|
|
extern PCALLBACK_OBJECT PowerStateCallbackObject;
|
|
extern PVOID PowerStateCallbackRegistration;
|
|
|
|
|
|
#define PAR_NO_FAST_CALLS 1
|
|
#if PAR_NO_FAST_CALLS
|
|
VOID
|
|
ParCompleteRequest(
|
|
IN PIRP Irp,
|
|
IN CCHAR PriorityBoost
|
|
);
|
|
|
|
NTSTATUS
|
|
ParCallDriver(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PIRP Irp
|
|
);
|
|
#else
|
|
#define ParCompleteRequest(a,b) IoCompleteRequest(a,b)
|
|
#define ParCallDriver(a,b) IoCallDriver(a,b)
|
|
#endif
|
|
|
|
extern const PHYSICAL_ADDRESS PhysicalZero;
|
|
|
|
//
|
|
// For the above directory, the serial port will
|
|
// use the following name as the suffix of the serial
|
|
// ports for that directory. It will also append
|
|
// a number onto the end of the name. That number
|
|
// will start at 1.
|
|
//
|
|
#define DEFAULT_PARALLEL_NAME L"LPT"
|
|
|
|
//
|
|
// This is the parallel class name.
|
|
//
|
|
#define DEFAULT_NT_SUFFIX L"Parallel"
|
|
|
|
|
|
#define PARALLEL_DATA_OFFSET 0
|
|
#define PARALLEL_STATUS_OFFSET 1
|
|
#define PARALLEL_CONTROL_OFFSET 2
|
|
#define PARALLEL_REGISTER_SPAN 3
|
|
|
|
//
|
|
// Ieee 1284 constants (Protocol Families)
|
|
//
|
|
#define FAMILY_NONE 0x0
|
|
#define FAMILY_REVERSE_NIBBLE 0x1
|
|
#define FAMILY_REVERSE_BYTE 0x2
|
|
#define FAMILY_ECP 0x3
|
|
#define FAMILY_EPP 0x4
|
|
#define FAMILY_BECP 0x5
|
|
#define FAMILY_MAX FAMILY_BECP
|
|
|
|
//
|
|
// For pnp id strings
|
|
//
|
|
#define MAX_ID_SIZE 256
|
|
|
|
// used to construct IEEE 1284.3 "Dot" name suffixes
|
|
// table lookup for integer to WCHAR conversion
|
|
#define PAR_UNICODE_PERIOD L'.'
|
|
#define PAR_UNICODE_COLON L':'
|
|
|
|
|
|
//
|
|
// DeviceStateFlags
|
|
//
|
|
#define PAR_DEVICE_DELETED ((ULONG)0x00000002) // IoDeleteDevice has been called
|
|
#define PAR_DEVICE_PAUSED ((ULONG)0x00000010) // stop-pending, stopped, or remove-pending states
|
|
#define PAR_DEVICE_PORT_REMOVE_PENDING ((ULONG)0x00000200) // our ParPort is in a Remove Pending State
|
|
|
|
#define PAR_REV_MODE_SKIP_MASK (CHANNEL_NIBBLE | BYTE_BIDIR | EPP_ANY | ECP_ANY)
|
|
#define PAR_FWD_MODE_SKIP_MASK (EPP_ANY | BOUNDED_ECP | ECP_HW_NOIRQ | ECP_HW_IRQ)
|
|
#define PAR_MAX_CHANNEL 127
|
|
#define PAR_COMPATIBILITY_RESET 300
|
|
|
|
|
|
//
|
|
// ParClass DeviceObject structure
|
|
//
|
|
// - Lists the ParClass created PODO and all PDOs associated with a specific ParPort device
|
|
//
|
|
typedef struct _PAR_DEVOBJ_STRUCT {
|
|
PUCHAR Controller; // host controller address for devices in this structure
|
|
PDEVICE_OBJECT LegacyPodo; // legacy or "raw" port device
|
|
PDEVICE_OBJECT EndOfChainPdo; // End-Of-Chain PnP device
|
|
PDEVICE_OBJECT Dot3Id0Pdo; // 1284.3 daisy chain device, 1284.3 deviceID == 0
|
|
PDEVICE_OBJECT Dot3Id1Pdo;
|
|
PDEVICE_OBJECT Dot3Id2Pdo;
|
|
PDEVICE_OBJECT Dot3Id3Pdo; // 1284.3 daisy chain device, 1284.3 deviceID == 3
|
|
PDEVICE_OBJECT LegacyZipPdo; // Legacy Zip Drive
|
|
PFILE_OBJECT pFileObject; // Need an open handle to ParPort device to prevent it
|
|
// from being removed out from under us
|
|
struct _PAR_DEVOBJ_STRUCT *Next;
|
|
} PAR_DEVOBJ_STRUCT, *PPAR_DEVOBJ_STRUCT;
|
|
|
|
//
|
|
// Used in device extension for DeviceType field
|
|
//
|
|
#define PAR_DEVTYPE_FDO 0x00000001
|
|
#define PAR_DEVTYPE_PODO 0x00000002
|
|
#define PAR_DEVTYPE_PDO 0x00000004
|
|
|
|
|
|
|
|
//
|
|
// Protocol structure definitions
|
|
//
|
|
|
|
typedef
|
|
BOOLEAN
|
|
(*PPROTOCOL_IS_MODE_SUPPORTED_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_CONNECT_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
typedef
|
|
VOID
|
|
(*PPROTOCOL_DISCONNECT_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_ENTER_FORWARD_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_EXIT_FORWARD_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_ENTER_REVERSE_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_EXIT_REVERSE_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef
|
|
VOID
|
|
(*PPROTOCOL_READSHADOW_ROUTINE) (
|
|
IN Queue *pShadowBuffer,
|
|
IN PUCHAR lpsBufPtr,
|
|
IN ULONG dCount,
|
|
OUT ULONG *fifoCount
|
|
);
|
|
|
|
typedef
|
|
BOOLEAN
|
|
(*PPROTOCOL_HAVEREADDATA_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PPROTOCOL_SET_INTERFACE_ADDRESS_ROUTINE) (
|
|
IN PPDO_EXTENSION Extension,
|
|
IN UCHAR Address
|
|
);
|
|
|
|
typedef struct _FORWARD_PTCL {
|
|
PPROTOCOL_IS_MODE_SUPPORTED_ROUTINE fnIsModeSupported;
|
|
PPROTOCOL_CONNECT_ROUTINE fnConnect;
|
|
PPROTOCOL_DISCONNECT_ROUTINE fnDisconnect;
|
|
PPROTOCOL_SET_INTERFACE_ADDRESS_ROUTINE fnSetInterfaceAddress;
|
|
PPROTOCOL_ENTER_FORWARD_ROUTINE fnEnterForward;
|
|
PPROTOCOL_EXIT_FORWARD_ROUTINE fnExitForward;
|
|
PPROTOCOL_WRITE_ROUTINE fnWrite;
|
|
USHORT Protocol;
|
|
USHORT ProtocolFamily;
|
|
} FORWARD_PTCL, *PFORWARD_PTCL;
|
|
|
|
typedef struct _REVERSE_PTCL {
|
|
PPROTOCOL_IS_MODE_SUPPORTED_ROUTINE fnIsModeSupported;
|
|
PPROTOCOL_CONNECT_ROUTINE fnConnect;
|
|
PPROTOCOL_DISCONNECT_ROUTINE fnDisconnect;
|
|
PPROTOCOL_SET_INTERFACE_ADDRESS_ROUTINE fnSetInterfaceAddress;
|
|
PPROTOCOL_ENTER_REVERSE_ROUTINE fnEnterReverse;
|
|
PPROTOCOL_EXIT_REVERSE_ROUTINE fnExitReverse;
|
|
PPROTOCOL_READSHADOW_ROUTINE fnReadShadow;
|
|
PPROTOCOL_HAVEREADDATA_ROUTINE fnHaveReadData;
|
|
PPROTOCOL_READ_ROUTINE fnRead;
|
|
USHORT Protocol;
|
|
USHORT ProtocolFamily;
|
|
} REVERSE_PTCL, *PREVERSE_PTCL;
|
|
|
|
extern FORWARD_PTCL afpForward[];
|
|
extern REVERSE_PTCL arpReverse[];
|
|
|
|
//
|
|
// WARNING...Make sure that enumeration matches the protocol array...
|
|
//
|
|
typedef enum _FORWARD_MODE {
|
|
|
|
FORWARD_FASTEST = 0, // 0
|
|
BOUNDED_ECP_FORWARD = FORWARD_FASTEST, // 0
|
|
ECP_HW_FORWARD_NOIRQ, // 1
|
|
EPP_HW_FORWARD, // 2
|
|
EPP_SW_FORWARD, // 3
|
|
ECP_SW_FORWARD, //......................// 4
|
|
IEEE_COMPAT_MODE, // 6
|
|
CENTRONICS_MODE, // 7
|
|
FORWARD_NONE // 8
|
|
|
|
} FORWARD_MODE;
|
|
|
|
typedef enum _REVERSE_MODE {
|
|
|
|
REVERSE_FASTEST = 0, // 0
|
|
BOUNDED_ECP_REVERSE = REVERSE_FASTEST, // 0
|
|
ECP_HW_REVERSE_NOIRQ, // 1
|
|
EPP_HW_REVERSE, // 2
|
|
EPP_SW_REVERSE, // 3
|
|
ECP_SW_REVERSE, //......................// 4
|
|
BYTE_MODE, // 5
|
|
NIBBLE_MODE, // 6
|
|
CHANNELIZED_NIBBLE_MODE, // 7
|
|
REVERSE_NONE // 8
|
|
|
|
} REVERSE_MODE;
|
|
|
|
//
|
|
// Ieee Extensibility constants
|
|
//
|
|
|
|
#define NIBBLE_EXTENSIBILITY 0x00
|
|
#define BYTE_EXTENSIBILITY 0x01
|
|
#define CHANNELIZED_EXTENSIBILITY 0x08
|
|
#define ECP_EXTENSIBILITY 0x10
|
|
#define BECP_EXTENSIBILITY 0x18
|
|
#define EPP_EXTENSIBILITY 0x40
|
|
#define DEVICE_ID_REQ 0x04
|
|
|
|
//
|
|
// Bit Definitions in the status register.
|
|
//
|
|
|
|
#define PAR_STATUS_NOT_ERROR 0x08 //not error on device
|
|
#define PAR_STATUS_SLCT 0x10 //device is selected (on-line)
|
|
#define PAR_STATUS_PE 0x20 //paper empty
|
|
#define PAR_STATUS_NOT_ACK 0x40 //not acknowledge (data transfer was not ok)
|
|
#define PAR_STATUS_NOT_BUSY 0x80 //operation in progress
|
|
|
|
//
|
|
// Bit Definitions in the control register.
|
|
//
|
|
|
|
#define PAR_CONTROL_STROBE 0x01 //to read or write data
|
|
#define PAR_CONTROL_AUTOFD 0x02 //to autofeed continuous form paper
|
|
#define PAR_CONTROL_NOT_INIT 0x04 //begin an initialization routine
|
|
#define PAR_CONTROL_SLIN 0x08 //to select the device
|
|
#define PAR_CONTROL_IRQ_ENB 0x10 //to enable interrupts
|
|
#define PAR_CONTROL_DIR 0x20 //direction = read
|
|
#define PAR_CONTROL_WR_CONTROL 0xc0 //the 2 highest bits of the control
|
|
// register must be 1
|
|
//
|
|
// More bit definitions.
|
|
//
|
|
|
|
#define DATA_OFFSET 0
|
|
#define DSR_OFFSET 1
|
|
#define DCR_OFFSET 2
|
|
|
|
#define OFFSET_DATA DATA_OFFSET // Put in for compatibility with legacy code
|
|
#define OFFSET_DSR DSR_OFFSET // Put in for compatibility with legacy code
|
|
#define OFFSET_DCR DCR_OFFSET // Put in for compatibility with legacy code
|
|
|
|
//
|
|
// Bit definitions for the DSR.
|
|
//
|
|
|
|
#define DSR_NOT_BUSY 0x80
|
|
#define DSR_NOT_ACK 0x40
|
|
#define DSR_PERROR 0x20
|
|
#define DSR_SELECT 0x10
|
|
#define DSR_NOT_FAULT 0x08
|
|
|
|
//
|
|
// More bit definitions for the DSR.
|
|
//
|
|
|
|
#define DSR_NOT_PTR_BUSY 0x80
|
|
#define DSR_NOT_PERIPH_ACK 0x80
|
|
#define DSR_WAIT 0x80
|
|
#define DSR_PTR_CLK 0x40
|
|
#define DSR_PERIPH_CLK 0x40
|
|
#define DSR_INTR 0x40
|
|
#define DSR_ACK_DATA_REQ 0x20
|
|
#define DSR_NOT_ACK_REVERSE 0x20
|
|
#define DSR_XFLAG 0x10
|
|
#define DSR_NOT_DATA_AVAIL 0x08
|
|
#define DSR_NOT_PERIPH_REQUEST 0x08
|
|
|
|
//
|
|
// Bit definitions for the DCR.
|
|
//
|
|
|
|
#define DCR_RESERVED 0xC0
|
|
#define DCR_DIRECTION 0x20
|
|
#define DCR_ACKINT_ENABLED 0x10
|
|
#define DCR_SELECT_IN 0x08
|
|
#define DCR_NOT_INIT 0x04
|
|
#define DCR_AUTOFEED 0x02
|
|
#define DCR_STROBE 0x01
|
|
|
|
//
|
|
// More bit definitions for the DCR.
|
|
//
|
|
|
|
#define DCR_NOT_1284_ACTIVE 0x08
|
|
#define DCR_ASTRB 0x08
|
|
#define DCR_NOT_REVERSE_REQUEST 0x04
|
|
#define DCR_NOT_HOST_BUSY 0x02
|
|
#define DCR_NOT_HOST_ACK 0x02
|
|
#define DCR_DSTRB 0x02
|
|
#define DCR_NOT_HOST_CLK 0x01
|
|
#define DCR_WRITE 0x01
|
|
|
|
#define DCR_NEUTRAL (DCR_RESERVED | DCR_SELECT_IN | DCR_NOT_INIT)
|
|
|
|
//
|
|
// Give a timeout of 300 seconds. Some postscript printers will
|
|
// buffer up a lot of commands then proceed to render what they
|
|
// have. The printer will then refuse to accept any characters
|
|
// until it's done with the rendering. This render process can
|
|
// take a while. We'll give it 300 seconds.
|
|
//
|
|
// Note that an application can change this value.
|
|
//
|
|
#define PAR_WRITE_TIMEOUT_VALUE 300
|
|
|
|
|
|
#ifdef JAPAN // IBM-J printers
|
|
|
|
//
|
|
// Support for IBM-J printers.
|
|
//
|
|
// When the printer operates in Japanese (PS55) mode, it redefines
|
|
// the meaning of parallel lines so that extended error status can
|
|
// be reported. It is roughly compatible with PC/AT, but we have to
|
|
// take care of a few cases where the status looks like PC/AT error
|
|
// condition.
|
|
//
|
|
// Status Busy /AutoFdXT Paper Empty Select /Fault
|
|
// ------ ---- --------- ----------- ------ ------
|
|
// Not RMR 1 1 1 1 1
|
|
// Head Alarm 1 1 1 1 0
|
|
// ASF Jam 1 1 1 0 0
|
|
// Paper Empty 1 0 1 0 0
|
|
// No Error 0 0 0 1 1
|
|
// Can Req 1 0 0 0 1
|
|
// Deselect 1 0 0 0 0
|
|
//
|
|
// The printer keeps "Not RMR" during the parallel port
|
|
// initialization, then it takes "Paper Empty", "No Error"
|
|
// or "Deselect". Other status can be thought as an
|
|
// H/W error condition.
|
|
//
|
|
// Namely, "Not RMR" conflicts with PAR_NO_CABLE and "Deselect"
|
|
// should also be regarded as another PAR_OFF_LINE. When the
|
|
// status is PAR_PAPER_EMPTY, the initialization is finished
|
|
// (we should not send init purlse again.)
|
|
//
|
|
// See ParInitializeDevice() for more information.
|
|
//
|
|
// [takashim]
|
|
|
|
#define PAR_OFF_LINE_COMMON( Status ) ( \
|
|
(IsNotNEC_98) ? \
|
|
(Status & PAR_STATUS_NOT_ERROR) && \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
!(Status & PAR_STATUS_SLCT) : \
|
|
\
|
|
((Status & PAR_STATUS_NOT_ERROR) ^ PAR_STATUS_NOT_ERROR) && \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
((Status & PAR_STATUS_PE) ^ PAR_STATUS_PE) && \
|
|
!(Status & PAR_STATUS_SLCT) \
|
|
)
|
|
|
|
#define PAR_OFF_LINE_IBM55( Status ) ( \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
((Status & PAR_STATUS_PE) ^ PAR_STATUS_PE) && \
|
|
((Status & PAR_STATUS_SLCT) ^ PAR_STATUS_SLCT) && \
|
|
((Status & PAR_STATUS_NOT_ERROR) ^ PAR_STATUS_NOT_ERROR))
|
|
|
|
#define PAR_PAPER_EMPTY2( Status ) ( \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
(Status & PAR_STATUS_PE) && \
|
|
((Status & PAR_STATUS_SLCT) ^ PAR_STATUS_SLCT) && \
|
|
((Status & PAR_STATUS_NOT_ERROR) ^ PAR_STATUS_NOT_ERROR))
|
|
|
|
//
|
|
// Redefine this for Japan.
|
|
//
|
|
|
|
#define PAR_OFF_LINE( Status ) ( \
|
|
PAR_OFF_LINE_COMMON( Status ) || \
|
|
PAR_OFF_LINE_IBM55( Status ))
|
|
|
|
#else // JAPAN
|
|
//
|
|
// Busy, not select, not error
|
|
//
|
|
// !JAPAN
|
|
|
|
#define PAR_OFF_LINE( Status ) ( \
|
|
(IsNotNEC_98) ? \
|
|
(Status & PAR_STATUS_NOT_ERROR) && \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
!(Status & PAR_STATUS_SLCT) : \
|
|
\
|
|
((Status & PAR_STATUS_NOT_ERROR) ^ PAR_STATUS_NOT_ERROR) && \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
((Status & PAR_STATUS_PE) ^ PAR_STATUS_PE) && \
|
|
!(Status & PAR_STATUS_SLCT) \
|
|
)
|
|
|
|
#endif // JAPAN
|
|
|
|
//
|
|
// Busy, PE
|
|
//
|
|
|
|
#define PAR_PAPER_EMPTY( Status ) ( \
|
|
(Status & PAR_STATUS_PE) )
|
|
|
|
//
|
|
// error, ack, not busy
|
|
//
|
|
|
|
#define PAR_POWERED_OFF( Status ) ( \
|
|
(IsNotNEC_98) ? \
|
|
((Status & PAR_STATUS_NOT_ERROR) ^ PAR_STATUS_NOT_ERROR) && \
|
|
((Status & PAR_STATUS_NOT_ACK) ^ PAR_STATUS_NOT_ACK) && \
|
|
(Status & PAR_STATUS_NOT_BUSY) : \
|
|
\
|
|
((Status & PAR_STATUS_NOT_ERROR) ^ PAR_STATUS_NOT_ERROR) && \
|
|
(Status & PAR_STATUS_NOT_ACK) && \
|
|
(Status & PAR_STATUS_NOT_BUSY) \
|
|
)
|
|
|
|
//
|
|
// not error, not busy, not select
|
|
//
|
|
|
|
#define PAR_NOT_CONNECTED( Status ) ( \
|
|
(Status & PAR_STATUS_NOT_ERROR) && \
|
|
(Status & PAR_STATUS_NOT_BUSY) &&\
|
|
!(Status & PAR_STATUS_SLCT) )
|
|
|
|
//
|
|
// not error, not busy
|
|
//
|
|
|
|
#define PAR_OK(Status) ( \
|
|
(Status & PAR_STATUS_NOT_ERROR) && \
|
|
((Status & PAR_STATUS_PE) ^ PAR_STATUS_PE) && \
|
|
(Status & PAR_STATUS_NOT_BUSY) )
|
|
|
|
//
|
|
// busy, select, not error
|
|
//
|
|
|
|
#define PAR_POWERED_ON(Status) ( \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
(Status & PAR_STATUS_SLCT) && \
|
|
(Status & PAR_STATUS_NOT_ERROR))
|
|
|
|
//
|
|
// busy, not error
|
|
//
|
|
|
|
#define PAR_BUSY(Status) (\
|
|
(( Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
( Status & PAR_STATUS_NOT_ERROR ) )
|
|
|
|
//
|
|
// selected
|
|
//
|
|
|
|
#define PAR_SELECTED(Status) ( \
|
|
( Status & PAR_STATUS_SLCT ) )
|
|
|
|
//
|
|
// No cable attached.
|
|
//
|
|
|
|
#define PAR_NO_CABLE(Status) ( \
|
|
(IsNotNEC_98) ? \
|
|
((Status & PAR_STATUS_NOT_BUSY) ^ PAR_STATUS_NOT_BUSY) && \
|
|
(Status & PAR_STATUS_NOT_ACK) && \
|
|
(Status & PAR_STATUS_PE) && \
|
|
(Status & PAR_STATUS_SLCT) && \
|
|
(Status & PAR_STATUS_NOT_ERROR) : \
|
|
\
|
|
(Status & PAR_STATUS_NOT_BUSY) && \
|
|
(Status & PAR_STATUS_NOT_ACK) && \
|
|
(Status & PAR_STATUS_PE) && \
|
|
(Status & PAR_STATUS_SLCT) && \
|
|
(Status & PAR_STATUS_NOT_ERROR) \
|
|
)
|
|
|
|
//
|
|
// not error, not busy, selected.
|
|
//
|
|
|
|
#define PAR_ONLINE(Status) ( \
|
|
(Status & PAR_STATUS_NOT_ERROR) && \
|
|
(Status & PAR_STATUS_NOT_BUSY) && \
|
|
((Status & PAR_STATUS_PE) ^ PAR_STATUS_PE) && \
|
|
(Status & PAR_STATUS_SLCT) )
|
|
|
|
|
|
//BOOLEAN
|
|
//ParCompareGuid(
|
|
// IN LPGUID guid1,
|
|
// IN LPGUID guid2
|
|
// )
|
|
//
|
|
#define ParCompareGuid(g1, g2) ( \
|
|
( (g1) == (g2) ) ? \
|
|
TRUE : \
|
|
RtlCompareMemory( (g1), (g2), sizeof(GUID) ) == sizeof(GUID) \
|
|
)
|
|
|
|
|
|
//VOID StoreData(
|
|
// IN PUCHAR RegisterBase,
|
|
// IN UCHAR DataByte
|
|
// )
|
|
// Data must be on line before Strobe = 1;
|
|
// Strobe = 1, DIR = 0
|
|
// Strobe = 0
|
|
//
|
|
// We change the port direction to output (and make sure stobe is low).
|
|
//
|
|
// Note that the data must be available at the port for at least
|
|
// .5 microseconds before and after you strobe, and that the strobe
|
|
// must be active for at least 500 nano seconds. We are going
|
|
// to end up stalling for twice as much time as we need to, but, there
|
|
// isn't much we can do about that.
|
|
//
|
|
// We put the data into the port and wait for 1 micro.
|
|
// We strobe the line for at least 1 micro
|
|
// We lower the strobe and again delay for 1 micro
|
|
// We then revert to the original port direction.
|
|
//
|
|
// Thanks to Olivetti for advice.
|
|
//
|
|
|
|
#define StoreData(RegisterBase,DataByte) \
|
|
{ \
|
|
PUCHAR _Address = RegisterBase; \
|
|
UCHAR _Control; \
|
|
_Control = GetControl(_Address); \
|
|
ASSERT(!(_Control & PAR_CONTROL_STROBE)); \
|
|
StoreControl( \
|
|
_Address, \
|
|
(UCHAR)(_Control & ~(PAR_CONTROL_STROBE | PAR_CONTROL_DIR)) \
|
|
); \
|
|
P5WritePortUchar( \
|
|
_Address+PARALLEL_DATA_OFFSET, \
|
|
(UCHAR)DataByte \
|
|
); \
|
|
KeStallExecutionProcessor((ULONG)1); \
|
|
StoreControl( \
|
|
_Address, \
|
|
(UCHAR)((_Control | PAR_CONTROL_STROBE) & ~PAR_CONTROL_DIR) \
|
|
); \
|
|
KeStallExecutionProcessor((ULONG)1); \
|
|
StoreControl( \
|
|
_Address, \
|
|
(UCHAR)(_Control & ~(PAR_CONTROL_STROBE | PAR_CONTROL_DIR)) \
|
|
); \
|
|
KeStallExecutionProcessor((ULONG)1); \
|
|
StoreControl( \
|
|
_Address, \
|
|
(UCHAR)_Control \
|
|
); \
|
|
}
|
|
|
|
//
|
|
// Function prototypes
|
|
//
|
|
|
|
//
|
|
// parpnp.c
|
|
//
|
|
#ifndef STATIC_LOAD
|
|
|
|
NTSTATUS
|
|
ParPnpAddDevice(
|
|
IN PDRIVER_OBJECT pDriverObject,
|
|
IN PDEVICE_OBJECT pPhysicalDeviceObject
|
|
);
|
|
|
|
NTSTATUS
|
|
ParParallelPnp (
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParSynchCompletionRoutine(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PKEVENT Event
|
|
);
|
|
|
|
BOOLEAN
|
|
ParMakeNames(
|
|
IN ULONG ParallelPortNumber,
|
|
OUT PUNICODE_STRING ClassName,
|
|
OUT PUNICODE_STRING LinkName
|
|
);
|
|
|
|
VOID
|
|
ParCheckParameters(
|
|
IN OUT PPDO_EXTENSION Extension
|
|
);
|
|
|
|
#endif
|
|
|
|
//
|
|
// oldinit.c
|
|
//
|
|
|
|
#ifdef STATIC_LOAD
|
|
|
|
NTSTATUS
|
|
DriverEntry(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PUNICODE_STRING RegistryPath
|
|
);
|
|
|
|
BOOLEAN
|
|
ParMakeNames(
|
|
IN ULONG ParallelPortNumber,
|
|
OUT PUNICODE_STRING PortName,
|
|
OUT PUNICODE_STRING ClassName,
|
|
OUT PUNICODE_STRING LinkName
|
|
);
|
|
|
|
VOID
|
|
ParInitializeClassDevice(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PUNICODE_STRING RegistryPath,
|
|
IN ULONG ParallelPortNumber
|
|
);
|
|
|
|
VOID
|
|
ParCheckParameters(
|
|
IN PUNICODE_STRING RegistryPath,
|
|
IN OUT PPDO_EXTENSION Extension
|
|
);
|
|
|
|
#endif
|
|
|
|
//
|
|
// parclass.c
|
|
//
|
|
|
|
VOID
|
|
ParLogError(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
|
|
IN PHYSICAL_ADDRESS P1,
|
|
IN PHYSICAL_ADDRESS P2,
|
|
IN ULONG SequenceNumber,
|
|
IN UCHAR MajorFunctionCode,
|
|
IN UCHAR RetryCount,
|
|
IN ULONG UniqueErrorValue,
|
|
IN NTSTATUS FinalStatus,
|
|
IN NTSTATUS SpecificIOStatus
|
|
);
|
|
|
|
NTSTATUS
|
|
ParCreateOpen(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParClose(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParCleanup(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
PptPdoReadWrite(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParDeviceControl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParInternalDeviceControl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParQueryInformationFile(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParSetInformationFile(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ParExportedNegotiateIeeeMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN USHORT ModeMaskFwd,
|
|
IN USHORT ModeMaskRev,
|
|
IN PARALLEL_SAFETY ModeSafety,
|
|
IN BOOLEAN IsForward
|
|
);
|
|
|
|
NTSTATUS
|
|
ParExportedTerminateIeeeMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
// Modes of operation
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// spp.c
|
|
//
|
|
|
|
NTSTATUS
|
|
ParEnterSppMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
ULONG
|
|
SppWriteLoopPI(
|
|
IN PUCHAR Controller,
|
|
IN PUCHAR WriteBuffer,
|
|
IN ULONG NumBytesToWrite,
|
|
IN ULONG BusyDelay
|
|
);
|
|
|
|
ULONG
|
|
SppCheckBusyDelay(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PUCHAR WriteBuffer,
|
|
IN ULONG NumBytesToWrite
|
|
);
|
|
|
|
NTSTATUS
|
|
SppWrite(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BytesToWrite,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
VOID
|
|
ParTerminateSppMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
SppQueryDeviceId(
|
|
IN PPDO_EXTENSION Extension,
|
|
OUT PCHAR DeviceIdBuffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG DeviceIdSize,
|
|
IN BOOLEAN bReturnRawString
|
|
);
|
|
|
|
//
|
|
// sppieee.c
|
|
//
|
|
NTSTATUS
|
|
SppIeeeWrite(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BytesToWrite,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
//
|
|
// nibble.c
|
|
//
|
|
|
|
BOOLEAN
|
|
ParIsChannelizedNibbleSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
BOOLEAN
|
|
ParIsNibbleSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterNibbleMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterChannelizedNibbleMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
VOID
|
|
ParTerminateNibbleMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParNibbleModeRead(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
//
|
|
// Byte.c
|
|
//
|
|
|
|
BOOLEAN
|
|
ParIsByteSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterByteMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
VOID
|
|
ParTerminateByteMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParByteModeRead(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
//
|
|
// epp.c
|
|
//
|
|
|
|
NTSTATUS
|
|
ParEppSetAddress(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN UCHAR Address
|
|
);
|
|
|
|
//
|
|
// hwepp.c
|
|
//
|
|
|
|
BOOLEAN
|
|
ParIsEppHwSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterEppHwMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
VOID
|
|
ParTerminateEppHwMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEppHwWrite(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEppHwRead(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
//
|
|
// swepp.c
|
|
//
|
|
|
|
BOOLEAN
|
|
ParIsEppSwWriteSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
BOOLEAN
|
|
ParIsEppSwReadSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterEppSwMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
VOID
|
|
ParTerminateEppSwMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEppSwWrite(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEppSwRead(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
//
|
|
// ecp.c and swecp.c
|
|
//
|
|
|
|
NTSTATUS
|
|
ParEcpEnterForwardPhase (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
BOOLEAN
|
|
ParEcpHaveReadData (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
BOOLEAN
|
|
ParIsEcpSwWriteSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
BOOLEAN
|
|
ParIsEcpSwReadSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterEcpSwMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
VOID
|
|
ParCleanupSwEcpPort(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
VOID
|
|
ParTerminateEcpMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpSetAddress(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN UCHAR Address
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpSwWrite(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpSwRead(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpForwardToReverse(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpReverseToForward(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
//
|
|
// hwecp.c
|
|
//
|
|
|
|
BOOLEAN
|
|
PptEcpHwHaveReadData (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpHwExitForwardPhase (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
PptEcpHwEnterReversePhase (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpHwExitReversePhase (
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
VOID
|
|
PptEcpHwDrainShadowBuffer(IN Queue *pShadowBuffer,
|
|
IN PUCHAR lpsBufPtr,
|
|
IN ULONG dCount,
|
|
OUT ULONG *fifoCount);
|
|
|
|
NTSTATUS
|
|
ParEcpHwRead(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpHwWrite(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpHwSetAddress(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN UCHAR Address
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterEcpHwMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
BOOLEAN
|
|
ParIsEcpHwSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEcpHwSetupPhase(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
VOID
|
|
ParTerminateHwEcpMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
//
|
|
// becp.c
|
|
//
|
|
|
|
NTSTATUS
|
|
PptBecpExitReversePhase(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
PptBecpRead(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
PptEnterBecpMode(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
BOOLEAN
|
|
PptIsBecpSupported(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
VOID
|
|
PptTerminateBecpMode(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
//
|
|
// p12843dl.c
|
|
//
|
|
NTSTATUS
|
|
ParDot3Connect(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
VOID
|
|
ParDot3CreateObject(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PCHAR DOT3DL,
|
|
IN PCHAR DOT3C
|
|
);
|
|
|
|
VOID
|
|
ParDot4CreateObject(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PCHAR DOT4DL
|
|
);
|
|
|
|
VOID
|
|
ParDot3ParseModes(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PCHAR DOT3M
|
|
);
|
|
|
|
VOID
|
|
ParMLCCreateObject(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PCHAR CMDField
|
|
);
|
|
|
|
VOID
|
|
ParDot3DestroyObject(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParDot3Disconnect(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParDot3Read(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParDot3Write(
|
|
IN PPDO_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
NTSTATUS
|
|
ParMLCCompatReset(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParMLCECPReset(
|
|
IN PPDO_EXTENSION Extension
|
|
);
|
|
|
|
#if DBG
|
|
VOID
|
|
ParInitDebugLevel (
|
|
IN PUNICODE_STRING RegistryPath
|
|
);
|
|
#endif
|
|
|
|
// former parclass.h preceeds
|
|
|
|
#endif // _PARPORT_H_
|