able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/parallel/parport2/debug.c

484 lines
12 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1998 - 1999
//
// File: debug.c
//
//--------------------------------------------------------------------------
#include "pch.h"
// Diagnostic globals - used during development
ULONG d1;
ULONG d2;
ULONG d3;
ULONG d4;
ULONG d5;
ULONG d6;
ULONG d7;
ULONG d8;
ULONG d9;
// Debug globals
ULONG Trace;
ULONG Break;
ULONG AllowAsserts = 0;
//
// set bits using PPT_DD_* bit defs to mask off debug spew for a specific device
//
ULONG DbgMaskFdo = 0;
ULONG DbgMaskRawPort = 0;
ULONG DbgMaskDaisyChain0 = 0;
ULONG DbgMaskDaisyChain1 = 0;
ULONG DbgMaskEndOfChain = 0;
ULONG DbgMaskLegacyZip = 0;
ULONG DbgMaskNoDevice = 0;
PCHAR PnpIrpName[] = {
"0x00 - IRP_MN_START_DEVICE",
"0x01 - IRP_MN_QUERY_REMOVE_DEVICE",
"0x02 - IRP_MN_REMOVE_DEVICE",
"0x03 - IRP_MN_CANCEL_REMOVE_DEVICE",
"0x04 - IRP_MN_STOP_DEVICE",
"0x05 - IRP_MN_QUERY_STOP_DEVICE",
"0x06 - IRP_MN_CANCEL_STOP_DEVICE",
"0x07 - IRP_MN_QUERY_DEVICE_RELATIONS",
"0x08 - IRP_MN_QUERY_INTERFACE",
"0x09 - IRP_MN_QUERY_CAPABILITIES",
"0x0A - IRP_MN_QUERY_RESOURCES",
"0x0B - IRP_MN_QUERY_RESOURCE_REQUIREMENTS",
"0x0C - IRP_MN_QUERY_DEVICE_TEXT",
"0x0D - IRP_MN_FILTER_RESOURCE_REQUIREMENTS",
"0x0E - unused Pnp MinorFunction",
"0x0F - IRP_MN_READ_CONFIG",
"0x10 - IRP_MN_WRITE_CONFIG",
"0x11 - IRP_MN_EJECT",
"0x12 - IRP_MN_SET_LOCK",
"0x13 - IRP_MN_QUERY_ID",
"0x14 - IRP_MN_QUERY_PNP_DEVICE_STATE",
"0x15 - IRP_MN_QUERY_BUS_INFORMATION",
"0x16 - IRP_MN_DEVICE_USAGE_NOTIFICATION",
"0x17 - IRP_MN_SURPRISE_REMOVAL",
"0x18 - IRP_MN_QUERY_LEGACY_BUS_INFORMATION"
};
PCHAR PhaseName[] = {
"PHASE_UNKNOWN",
"PHASE_NEGOTIATION",
"PHASE_SETUP", // Used in ECP mode only
"PHASE_FORWARD_IDLE",
"PHASE_FORWARD_XFER",
"PHASE_FWD_TO_REV",
"PHASE_REVERSE_IDLE",
"PHASE_REVERSE_XFER",
"PHASE_REV_TO_FWD",
"PHASE_TERMINATE",
"PHASE_DATA_AVAILABLE", // Used in nibble and byte modes only
"PHASE_DATA_NOT_AVAIL", // Used in nibble and byte modes only
"PHASE_INTERRUPT_HOST" // Used in nibble and byte modes only
};
#if 1 == DBG_SHOW_BYTES
ULONG DbgShowBytes = 1; // turn off via reg setting: Services\Parport\Parameters\DbgShowBytes : REG_DWORD : 0x0
#endif
#if 1 == PptEnableDebugSpew
VOID
P5TraceIrpArrival( PDEVICE_OBJECT DevObj, PIRP Irp ) {
PCOMMON_EXTENSION cdx = DevObj->DeviceExtension;
DD(cdx,DDE,"Irp arrival %x\n",Irp);
}
VOID
P5TraceIrpCompletion( PIRP Irp ) {
//PCOMMON_EXTENSION cdx = DevObj->DeviceExtension;
DD(NULL,DDE,"Irp completion %x\n",Irp);
}
VOID
P5SetPhase( PPDO_EXTENSION Pdx, P1284_PHASE Phase ) {
LARGE_INTEGER tickCount;
KeQueryTickCount( &tickCount );
if( Pdx->CurrentPhase != Phase ) {
Pdx->CurrentPhase = Phase;
PptAssert(Phase < arraysize(PhaseName));
DD((PCE)Pdx,DDT,"P5SetPhase at %I64x to %2d - %s\n",tickCount,Phase,PhaseName[Phase]);
}
}
VOID
P5BSetPhase( PIEEE_STATE IeeeState, P1284_PHASE Phase ) {
LARGE_INTEGER tickCount;
KeQueryTickCount( &tickCount );
if( IeeeState->CurrentPhase != Phase ) {
IeeeState->CurrentPhase = Phase;
PptAssert(Phase < arraysize(PhaseName));
DD(NULL,DDT,"P5BSetPhase at %I64x to %2d - %s\n",tickCount,Phase,PhaseName[Phase]);
}
}
#include "stdarg.h"
VOID
PptPrint( PCOMMON_EXTENSION Ext, ULONG Flags, PCHAR FmtStr, ... )
{
CHAR buf[ 256 ];
LONG count;
va_list va;
const LONG bufSize = sizeof(buf);
const LONG maxLocationLength = sizeof("LPTx.y: ");
ULONG trace;
ULONG mask;
PPDO_EXTENSION pdx;
PCHAR location;
PptAssertMsg( "0 == Flags", Flags );
PptAssertMsg( "NULL FmtStr", FmtStr );
if( Ext ) {
location = Ext->Location;
if( (NULL == location) || ('\0' == *location) ) {
location = "NoLoc";
}
switch( Ext->DevType ) {
case DevTypeFdo:
mask = DbgMaskFdo;
break;
case DevTypePdo:
pdx = (PPDO_EXTENSION)Ext;
switch( pdx->PdoType ) {
case PdoTypeRawPort:
mask = DbgMaskRawPort;
break;
case PdoTypeEndOfChain:
mask = DbgMaskEndOfChain;
break;
case PdoTypeDaisyChain:
switch( pdx->Ieee1284_3DeviceId ) {
case 0:
mask = DbgMaskDaisyChain0;
break;
case 1:
mask = DbgMaskDaisyChain1;
break;
default:
mask = 0;
PptAssert(FALSE);
}
break;
case PdoTypeLegacyZip:
mask = DbgMaskLegacyZip;
break;
default:
// PptAssertMsg( "Invalid PdoType", FALSE );
mask = 0;
}
break;
default:
// PptAssert(FALSE);
mask = 0;
}
} else {
// not device specific
location = "LPTx";
mask = DbgMaskNoDevice;
}
trace = Flags & Trace & ~mask;
if( trace != 0 ) {
va_start( va, FmtStr );
__try {
count = _snprintf( buf, maxLocationLength, "%-6s: ", location );
if( count < 0 ) {
__leave;
}
count += _vsnprintf( buf+count, bufSize-count-1, FmtStr, va );
if( count >= bufSize ) {
__leave;
}
DbgPrint( "%s", buf );
}
__finally {
va_end( va );
}
} // endif ( trace != 0 )
return;
}
UCHAR
P5ReadPortUchar( PUCHAR Port ) {
UCHAR value;
value = READ_PORT_UCHAR( Port );
if( d1 ) {
DbgPrint("zzz - READ_ PORT_UCHAR %x %02x\n",Port,value);
}
return value;
}
VOID
P5ReadPortBufferUchar( PUCHAR Port, PUCHAR Buffer, ULONG Count ) {
READ_PORT_BUFFER_UCHAR( Port, Buffer, Count );
return;
}
VOID
P5WritePortUchar( PUCHAR Port, UCHAR Value ) {
if( d1 ) {
DbgPrint("zzz - WRITE_PORT_UCHAR %x %02x\n",Port,Value);
}
WRITE_PORT_UCHAR( Port, Value );
return;
}
VOID
P5WritePortBufferUchar( PUCHAR Port, PUCHAR Buffer, ULONG Count )
{
WRITE_PORT_BUFFER_UCHAR( Port, Buffer, Count );
return;
}
VOID
PptFdoDumpPnpIrpInfo(
PDEVICE_OBJECT Fdo,
PIRP Irp
)
{
PFDO_EXTENSION fdx = Fdo->DeviceExtension;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
ULONG minorFunction = irpSp->MinorFunction;
PptAssert( DevTypeFdo == fdx->DevType );
if( minorFunction < arraysize(PnpIrpName) ) {
DD((PCE)fdx,DDT,"PptFdoDumpPnpIrpInfo - %s\n",PnpIrpName[ minorFunction ]);
} else {
DD((PCE)fdx,DDT,"PptFdoDumpPnpIrpInfo - bogus MinorFunction = %x\n",minorFunction);
}
}
VOID
PptPdoDumpPnpIrpInfo(
PDEVICE_OBJECT Pdo,
PIRP Irp
)
{
PPDO_EXTENSION pdx = Pdo->DeviceExtension;
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation( Irp );
ULONG minorFunction = irpSp->MinorFunction;
PptAssert( DevTypePdo == pdx->DevType );
if( minorFunction < arraysize(PnpIrpName) ) {
DD((PCE)pdx,DDT,"PptPdoDumpPnpIrpInfo - %s\n",PnpIrpName[ minorFunction ]);
} else {
DD((PCE)pdx,DDT,"PptPdoDumpPnpIrpInfo - bogus MinorFunction = %x\n",minorFunction);
}
}
NTSTATUS
PptAcquireRemoveLock(
IN PIO_REMOVE_LOCK RemoveLock,
IN PVOID Tag OPTIONAL
)
{
return IoAcquireRemoveLock(RemoveLock, Tag);
}
VOID
PptReleaseRemoveLock(
IN PIO_REMOVE_LOCK RemoveLock,
IN PVOID Tag OPTIONAL
)
{
IoReleaseRemoveLock(RemoveLock, Tag);
}
VOID
PptReleaseRemoveLockAndWait(
IN PIO_REMOVE_LOCK RemoveLock,
IN PVOID Tag
)
{
IoReleaseRemoveLockAndWait(RemoveLock, Tag);
}
#endif // 1 == PptEnableDebugSpew
#if (1 == DVRH_PAR_LOGFILE)
#include "stdarg.h"
/**************************************************************************
Function: DVRH_LogMessage()
Description:Logs message to configured output
Inputs: Parameter indicated message log level and
Format string and parameters
Outputs: Boolean value indicating success or failure
***************************************************************************/
BOOLEAN DVRH_LogMessage(PCHAR szFormat, ...)
{
ULONG Length;
char messagebuf[256];
va_list va;
IO_STATUS_BLOCK IoStatus;
OBJECT_ATTRIBUTES objectAttributes;
NTSTATUS status;
HANDLE FileHandle;
UNICODE_STRING fileName;
//format the string
va_start(va,szFormat);
_vsnprintf(messagebuf,sizeof(messagebuf),szFormat,va);
va_end(va);
//get a handle to the log file object
fileName.Buffer = NULL;
fileName.Length = 0;
fileName.MaximumLength = sizeof(DEFAULT_LOG_FILE_NAME) + sizeof(UNICODE_NULL);
fileName.Buffer = ExAllocatePool(PagedPool,
fileName.MaximumLength);
if (!fileName.Buffer) {
DD(NULL,DDE,"LogMessage: FAIL. ExAllocatePool Failed.\n");
return FALSE;
}
RtlZeroMemory(fileName.Buffer, fileName.MaximumLength);
status = RtlAppendUnicodeToString(&fileName, (PWSTR)DEFAULT_LOG_FILE_NAME);
InitializeObjectAttributes (&objectAttributes,
(PUNICODE_STRING)&fileName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL );
status = ZwCreateFile( &FileHandle,
FILE_APPEND_DATA,
&objectAttributes,
&IoStatus,
0,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_WRITE,
FILE_OPEN_IF,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0 );
if( NT_SUCCESS(status) ) {
CHAR buf[300];
LARGE_INTEGER time;
KeQuerySystemTime(&time);
//put a time stamp on the output message
sprintf(buf,"%10u-%10u %s",time.HighPart,time.LowPart,messagebuf);
//format the string to make sure it appends a newline carrage-return to the
//end of the string.
Length=strlen(buf);
if( buf[Length-1]=='\n' ) {
buf[Length-1]='\r';
strcat(buf,"\n");
Length++;
} else {
strcat(buf,"\r\n");
Length+=2;
}
ZwWriteFile( FileHandle, NULL, NULL, NULL, &IoStatus, buf, Length, NULL, NULL );
ZwClose( FileHandle );
}
if( fileName.Buffer ) {
ExFreePool (fileName.Buffer);
}
return STATUS_SUCCESS;
}
/**************************************************************************
Function: DVRH_LogByteData()
Description:Formats byte data to be displayed in the configured output
Inputs: Log level, Whether this is input or output data, a pointer to
the byte data buffer and the size of the buffer
Outputs: Boolean indicated success or failure
***************************************************************************/
BOOLEAN DVRH_LogByteData(BOOLEAN READ,PCHAR szBuff,ULONG dwTransferred)
{
CString cStr;
ULONG MAX_SIZE=80;
UNICODE_STRING UniStr;
ANSI_STRING AnsiStr;
WCHAR wStr[8];
PCHAR szTemp=szBuff;
UCHAR bTemp;
ULONG dwDisplaySize;
UniStr.Length=0;
UniStr.MaximumLength=8;
UniStr.Buffer=wStr;
AnsiStr.Length=0;
AnsiStr.MaximumLength=0;
AnsiStr.Buffer=NULL;
if(READ)
cStr=L"<RCV";
else
cStr=L"SND>";
//make sure the size of the requested string is within the set range
dwDisplaySize=(((dwTransferred*3)+10) > MAX_SIZE)?((MAX_SIZE-10)/3):dwTransferred;
//format byte data
while(dwDisplaySize)
{
bTemp=szTemp[0];
if(bTemp > 0xF)
cStr+=L" ";
else
cStr+=L" 0";
RtlIntegerToUnicodeString(bTemp,16,&UniStr);
cStr+=UniStr.Buffer;
szTemp++;
dwDisplaySize--;
}
cStr.StringToAnsiString(&AnsiStr);
LogMessage("%5u %s",dwTransferred,AnsiStr.Buffer);
RtlFreeAnsiString(&AnsiStr);
return (TRUE);
}
#endif // (1 == DVRH_PAR_LOGFILE)
Reference in a new issue Copy permalink