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

895 lines
29 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: readwrit.c
//
//--------------------------------------------------------------------------
//
// This file contains functions associated with handling Read and Write requests
//
#include "pch.h"
#include "ecp.h"
#include "readwrit.h"
NTSTATUS
ParForwardToReverse(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine flips the bus from Forward to Reverse direction.
Arguments:
Extension - Supplies the device extension.
Return Value:
None.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
// Do a quick check to see if we are where we want to be.
// Happy punt if everything is ok.
if (Extension->Connected &&
(Extension->CurrentPhase == PHASE_REVERSE_IDLE ||
Extension->CurrentPhase == PHASE_REVERSE_XFER))
{
ParDump2(PARINFO, ( "ParForwardToReverse: Already in Reverse Mode!\r\n" ));
return Status;
}
if (Extension->Connected) {
if (Extension->CurrentPhase != PHASE_REVERSE_IDLE &&
Extension->CurrentPhase != PHASE_REVERSE_XFER) {
if (afpForward[Extension->IdxForwardProtocol].ProtocolFamily ==
arpReverse[Extension->IdxReverseProtocol].ProtocolFamily) {
ParDump2(PARINFO, ( "ParForwardToReverse: Protocol families match!\r\n" ));
// Protocol Families match and we are in Fwd. Exit Fwd to cleanup the state
// machine, fifo, etc. We will call EnterReverse later to
// actually bus flip. Also only do this if in safe mode
if ( (afpForward[Extension->IdxForwardProtocol].fnExitForward) ) {
Status = afpForward[Extension->IdxForwardProtocol].fnExitForward(Extension);
}
} else {
ParDump2(PARINFO, ( "ParForwardToReverse: Protocol families DO NOT match!\r\n" ));
//
// Protocol Families don't match...need to terminate from the forward mode
//
if (afpForward[Extension->IdxForwardProtocol].fnDisconnect)
{
ParDump2(PARINFO, ("ParForwardToReverse: Calling afpForward.fnDisconnect\r\n"));
afpForward[Extension->IdxForwardProtocol].fnDisconnect (Extension);
}
if ((Extension->ForwardInterfaceAddress != DEFAULT_ECP_CHANNEL) &&
(afpForward[Extension->IdxForwardProtocol].fnSetInterfaceAddress))
Extension->SetForwardAddress = TRUE;
}
}
}
if ((!Extension->Connected) &&
(arpReverse[Extension->IdxReverseProtocol].fnConnect)) {
ParDump2(PARINFO, ( "ParForwardToReverse: Not Connected so Calling Reverse Connect!\r\n" ));
//
// If we are still connected the protocol families match...
//
Status = arpReverse[Extension->IdxReverseProtocol].fnConnect(Extension, FALSE);
//
// Makes the assumption that the connected address is always 0
//
if ((NT_SUCCESS(Status)) &&
(arpReverse[Extension->IdxReverseProtocol].fnSetInterfaceAddress) &&
(Extension->ReverseInterfaceAddress != DEFAULT_ECP_CHANNEL)) {
Extension->SetReverseAddress = TRUE;
}
}
//
// Set the channel address if we need to.
//
if (NT_SUCCESS(Status) && Extension->SetReverseAddress &&
(arpReverse[Extension->IdxReverseProtocol].fnSetInterfaceAddress)) {
Status = arpReverse[Extension->IdxReverseProtocol].fnSetInterfaceAddress (
Extension,
Extension->ReverseInterfaceAddress);
if (NT_SUCCESS(Status))
Extension->SetReverseAddress = FALSE;
else
Extension->SetReverseAddress = TRUE;
}
//
// Do we need to reverse?
//
if ( (NT_SUCCESS(Status)) &&
((Extension->CurrentPhase != PHASE_REVERSE_IDLE) &&
(Extension->CurrentPhase != PHASE_REVERSE_XFER)) ) {
ParDump2(PARINFO, ( "ParForwardToReverse: Not IN REVERSE IDLE so Calling Reverse ENTER!\r\n" ));
if ((arpReverse[Extension->IdxReverseProtocol].fnEnterReverse))
Status = arpReverse[Extension->IdxReverseProtocol].fnEnterReverse(Extension);
}
ParDump2(PAREXIT, ( "ParForwardToReverse: Exit [%d]\r\n", NT_SUCCESS(Status)));
return Status;
}
BOOLEAN
ParHaveReadData(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This method determines if the peripheral has any data ready
to send to the host.
Arguments:
Extension - Supplies the device EXTENSION.
Return Value:
TRUE - Either the peripheral has data
FALSE - No data
--*/
{
if (Extension->CurrentPhase == PHASE_REVERSE_IDLE ||
Extension->CurrentPhase == PHASE_REVERSE_XFER)
{
if (arpReverse[Extension->IdxReverseProtocol].fnHaveReadData)
{
if (arpReverse[Extension->IdxReverseProtocol].fnHaveReadData(Extension))
return TRUE;
// Don't have data. This could be a fluke. Let's
// flip the bus and try in Fwd mode.
ParReverseToForward(Extension);
}
}
if (Extension->CurrentPhase == PHASE_FORWARD_IDLE ||
Extension->CurrentPhase == PHASE_FORWARD_XFER)
{
if (afpForward[Extension->IdxForwardProtocol].ProtocolFamily == FAMILY_BECP ||
afpForward[Extension->IdxForwardProtocol].Protocol & ECP_HW_NOIRQ ||
afpForward[Extension->IdxForwardProtocol].Protocol & ECP_HW_IRQ)
{
if (ParEcpHwHaveReadData(Extension))
return TRUE;
// Hmmm. No data. Is the chip stuck?
#define DVRH_DO_RETRY 0
#if (1 == DVRH_DO_RETRY)
// retry - slap periph to wake it up, then try again
ParPing(Extension);
return ParEcpHwHaveReadData(Extension);
#else
return FALSE;
#endif
}
else if (afpForward[Extension->IdxForwardProtocol].Protocol & ECP_SW)
return ParEcpHaveReadData(Extension);
}
// DVRH RMT
// We got here because the protocol doesn't support peeking.
// Let's go ahead and flip the bus to see if there is anything
// there.
return TRUE;
}
NTSTATUS
ParPing(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This method pings the device.
Arguments:
Extension - Supplies the device EXTENSION.
Return Value:
none
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
#if 0
if ((Extension->CurrentPhase == PHASE_REVERSE_IDLE) ||
(Extension->CurrentPhase == PHASE_REVERSE_XFER))
{
ParReverseToForward(Extension);
if (arpReverse[Extension->IdxReverseProtocol].fnDisconnect)
{
ParDump2(PARINFO, ("ParPing: Calling arpReverse.fnDisconnect\n"));
arpReverse[Extension->IdxReverseProtocol].fnDisconnect(Extension);
}
} else if ((Extension->CurrentPhase != PHASE_REVERSE_IDLE) &&
(Extension->CurrentPhase != PHASE_REVERSE_XFER))
{
if (afpForward[Extension->IdxForwardProtocol].fnDisconnect)
{
ParDump2(PARINFO, ("ParPing: Calling afpForward.fnDisconnect\n"));
afpForward[Extension->IdxForwardProtocol].fnDisconnect(Extension);
}
}
if (afpForward[Extension->IdxForwardProtocol].fnConnect)
{
NtStatus = afpForward[Extension->IdxForwardProtocol].fnConnect(Extension, FALSE);
if (NT_SUCCESS(NtStatus) &&
(Extension->ForwardInterfaceAddress != DEFAULT_ECP_CHANNEL) &&
(afpForward[Extension->IdxForwardProtocol].fnSetInterfaceAddress))
{
NtStatus = afpForward[Extension->IdxForwardProtocol].fnSetInterfaceAddress(Extension, Extension->ForwardInterfaceAddress);
}
}
#endif
return NtStatus;
}
NTSTATUS
ParReadWrite(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This is the dispatch routine for READ and WRITE requests.
Arguments:
DeviceObject - Supplies the device object.
Irp - Supplies the I/O request packet.
Return Value:
STATUS_PENDING - Request pending - a worker thread will carry
out the request at PASSIVE_LEVEL IRQL
STATUS_SUCCESS - Success - asked for a read or write of
length zero.
STATUS_INVALID_PARAMETER - Invalid parameter.
STATUS_DELETE_PENDING - This device object is being deleted.
--*/
{
PIO_STACK_LOCATION IrpSp;
PDEVICE_EXTENSION Extension;
Irp->IoStatus.Information = 0;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
Extension = DeviceObject->DeviceExtension;
ParTimerMainCheck( ("Enter ParReadWrite(...) - %wZ\r\n", &Extension->SymbolicLinkName) );
//
// bail out if a delete is pending for this device object
//
if(Extension->DeviceStateFlags & PAR_DEVICE_DELETE_PENDING) {
Irp->IoStatus.Status = STATUS_DELETE_PENDING;
ParCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_DELETE_PENDING;
}
//
// bail out if a remove is pending for our ParPort device object
//
if(Extension->DeviceStateFlags & PAR_DEVICE_PORT_REMOVE_PENDING) {
Irp->IoStatus.Status = STATUS_DELETE_PENDING;
ParCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_DELETE_PENDING;
}
//
// bail out if device has been removed
//
if(Extension->DeviceStateFlags & (PAR_DEVICE_REMOVED|PAR_DEVICE_SURPRISE_REMOVAL) ) {
Irp->IoStatus.Status = STATUS_DEVICE_REMOVED;
ParCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_DEVICE_REMOVED;
}
//
// Note that checks of the Write IRP parameters also handles Read IRPs
// because the Write and Read structures are identical in the
// IO_STACK_LOCATION.Parameters union
//
//
// bail out on nonzero offset
//
if( (IrpSp->Parameters.Write.ByteOffset.HighPart != 0) ||
(IrpSp->Parameters.Write.ByteOffset.LowPart != 0) ) {
Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
ParCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INVALID_PARAMETER;
}
//
// immediately succeed read or write request of length zero
//
if (IrpSp->Parameters.Write.Length == 0) {
Irp->IoStatus.Status = STATUS_SUCCESS;
ParCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
//
// Request appears to be valid, queue it for our worker thread to handle at
// PASSIVE_LEVEL IRQL and wake up the thread to do the work
//
{
KIRQL OldIrql;
// make sure IRP isn't cancelled out from under us
IoAcquireCancelSpinLock(&OldIrql);
if (Irp->Cancel) {
// IRP has been cancelled, bail out
IoReleaseCancelSpinLock(OldIrql);
return STATUS_CANCELLED;
} else {
BOOLEAN needToSignalSemaphore = IsListEmpty( &Extension->WorkQueue );
IoSetCancelRoutine(Irp, ParCancelRequest);
IoMarkIrpPending(Irp);
InsertTailList(&Extension->WorkQueue, &Irp->Tail.Overlay.ListEntry);
IoReleaseCancelSpinLock(OldIrql);
if( needToSignalSemaphore ) {
KeReleaseSemaphore(&Extension->RequestSemaphore, 0, 1, FALSE);
}
return STATUS_PENDING;
}
}
}
NTSTATUS
ParRead(
IN PDEVICE_EXTENSION Extension,
OUT PVOID Buffer,
IN ULONG NumBytesToRead,
OUT PULONG NumBytesRead
)
{
NTSTATUS Status = STATUS_SUCCESS;
PUCHAR lpsBufPtr = (PUCHAR)Buffer; // Pointer to buffer cast to desired data type
ULONG Bytes = 0;
#if (1 == DVRH_RAISE_IRQL)
KIRQL OldIrql;
#endif
*NumBytesRead = Bytes;
#if (1 == DVRH_RAISE_IRQL)
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
#endif
// only do this if we are in safe mode
if ( Extension->ModeSafety == SAFE_MODE ) {
if (arpReverse[Extension->IdxReverseProtocol].fnReadShadow) {
Queue *pQueue;
pQueue = &(Extension->ShadowBuffer);
arpReverse[Extension->IdxReverseProtocol].fnReadShadow(pQueue,
lpsBufPtr,
NumBytesToRead,
&Bytes);
NumBytesToRead -= Bytes;
*NumBytesRead += Bytes;
lpsBufPtr += Bytes;
if ( 0 == NumBytesToRead ) {
ParDump2(PARINFO, ( "ParRead: Read everything from the ShadowBuffer\r\n" ));
Status = STATUS_SUCCESS;
if ((!Queue_IsEmpty(pQueue)) &&
(TRUE == Extension->P12843DL.bEventActive) ) {
KeSetEvent(Extension->P12843DL.Event, 0, FALSE);
}
goto ParRead_ExitLabel;
}
}
if (arpReverse[Extension->IdxReverseProtocol].fnHaveReadData) {
if (!arpReverse[Extension->IdxReverseProtocol].fnHaveReadData(Extension))
{
ParDump2(PARINFO, ( "ParRead: Periph doesn't have data. Happy punt to give cycles to someone else.\r\n" ));
Status = STATUS_SUCCESS;
goto ParRead_ExitLabel;
}
}
}
// Go ahead and flip the bus if need be. The proc will just make sure we're properly
// connected and pointing in the right direction.
Status = ParForwardToReverse( Extension );
//
// The read mode will vary depending upon the currently negotiated mode.
// Default: Nibble
//
if (NT_SUCCESS(Status))
{
#if (1 == DVRH_USE_CORRECT_PTRS)
if (Extension->fnRead || arpReverse[Extension->IdxReverseProtocol].fnRead) {
//
// Do the read...
//
if(Extension->fnRead) {
Status = ((PPROTOCOL_READ_ROUTINE)Extension->fnRead)(Extension,
(PVOID)lpsBufPtr,
NumBytesToRead,
&Bytes);
} else {
Status = arpReverse[Extension->IdxReverseProtocol].fnRead(Extension,
(PVOID)lpsBufPtr,
NumBytesToRead,
&Bytes);
}
#else
if (arpReverse[Extension->IdxReverseProtocol].fnRead) {
//
// Do the read...
//
Status = arpReverse[Extension->IdxReverseProtocol].fnRead(Extension,
(PVOID)lpsBufPtr,
NumBytesToRead,
&Bytes);
#endif
*NumBytesRead += Bytes;
NumBytesToRead -= Bytes;
#if DVRH_SHOW_BYTE_LOG
{
ULONG i=0;
DbgPrint("Parallel:Read: ");
for (i=0; i<*NumBytesRead; ++i) {
DbgPrint(" %02x",((PUCHAR)lpsBufPtr)[i]);
}
DbgPrint("\n");
}
#endif
}
#if DBG
else {
ParDump2(PARERRORS, ( "ParRead: Don't have a fnRead! Can't Read!\r\n" ));
ParDump2(PARERRORS, ( "ParRead: You're hosed man.\r\n" ));
ParDump2(PARERRORS, ( "ParRead: If you are here, you've got a bug somewhere else.\r\n" ));
ParDump2(PARERRORS, ( "ParRead: Go fix it!\r\n" ));
}
#endif
}
#if DBG
else {
ParDump2(PARERRORS, ( "ParRead: Failure from Above! Didn't call Read!\r\n" ));
ParDump2(PARERRORS, ( "ParRead: You're hosed man.\r\n" ));
ParDump2(PARERRORS, ( "ParRead: If you are here, you've got a bug somewhere else.\r\n" ));
ParDump2(PARERRORS, ( "ParRead: Go fix it!\r\n" ));
}
#endif
ParRead_ExitLabel:
#if (1 == DVRH_RAISE_IRQL)
KeLowerIrql(OldIrql);
#endif
return Status;
}
VOID
ParReadIrp(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine implements a READ request with the extension's current irp.
Arguments:
Extension - Supplies the device extension.
Return Value:
None.
--*/
{
PIRP Irp;
PIO_STACK_LOCATION IrpSp;
ULONG NumBytesRead;
Irp = Extension->CurrentOpIrp;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
ParDump2(PARENTRY, ( "ParReadIrp: Start. BytesToRead[%d]\r\n", IrpSp->Parameters.Read.Length ));
ParTimerCheck(( "ParReadIrp: Start. BytesToRead[%d]\r\n", IrpSp->Parameters.Read.Length ));
Irp->IoStatus.Status = ParRead( Extension,
Irp->AssociatedIrp.SystemBuffer,
IrpSp->Parameters.Read.Length,
&NumBytesRead);
Irp->IoStatus.Information = NumBytesRead;
ParTimerCheck(( "ParReadIrp: End. BytesRead[%d]\r\n", NumBytesRead ));
}
NTSTATUS
ParReverseToForward(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine flips the bus from Reverse to Forward direction.
Arguments:
Extension - Supplies the device extension.
Return Value:
None.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
// dvdr
ParDump2(PARINFO, ("ParReverseToForward: Entering\n"));
if (Extension->Connected)
{
// Do a quick check to see if we are where we want to be.
// Happy punt if everything is ok.
if (Extension->CurrentPhase == PHASE_FORWARD_IDLE ||
Extension->CurrentPhase == PHASE_FORWARD_XFER)
{
ParDump2(PAREXIT, ( "ParReverseToForward: Already in Fwd. Exit STATUS_SUCCESS\n" ));
return Status;
}
else
{
if (afpForward[Extension->IdxForwardProtocol].ProtocolFamily !=
arpReverse[Extension->IdxReverseProtocol].ProtocolFamily)
{
//
// Protocol Families don't match...need to terminate from the forward mode
//
if (arpReverse[Extension->IdxReverseProtocol].fnDisconnect) {
ParDump2(PARINFO, ("ParReverseToForward: Calling arpReverse.fnDisconnect\r\n"));
arpReverse[Extension->IdxReverseProtocol].fnDisconnect (Extension);
}
if ((Extension->ReverseInterfaceAddress != DEFAULT_ECP_CHANNEL) &&
(arpReverse[Extension->IdxReverseProtocol].fnSetInterfaceAddress))
Extension->SetReverseAddress = TRUE;
}
else if ((Extension->CurrentPhase == PHASE_REVERSE_IDLE) ||
(Extension->CurrentPhase == PHASE_REVERSE_XFER))
{
if ( (arpReverse[Extension->IdxReverseProtocol].fnExitReverse) ) {
Status = arpReverse[Extension->IdxReverseProtocol].fnExitReverse(Extension);
}
}
else
{
// We are in a screwy state.
ParDump2(PARERRORS, ( "ParReverseToForward: We're lost! Gonna start spewing!\r\n" ));
ParDump2(PARERRORS, ( "ParReverseToForward: You're hosed man.\r\n" ));
ParDump2(PARERRORS, ( "ParReverseToForward: If you are here, you've got a bug somewhere else.\r\n" ));
ParDump2(PARERRORS, ( "ParReverseToForward: Go fix it!\r\n" ));
Status = STATUS_IO_TIMEOUT; // I picked a RetVal from thin air!
}
}
}
// Yes, we stil want to check for connection since we might have temrinated in the previous
// code block!
if (!Extension->Connected &&
afpForward[Extension->IdxForwardProtocol].fnConnect) {
Status = afpForward[Extension->IdxForwardProtocol].fnConnect (
Extension,
FALSE);
//
// Makes the assumption that the connected address is always 0
//
if ((NT_SUCCESS(Status)) &&
(Extension->ForwardInterfaceAddress != DEFAULT_ECP_CHANNEL)) {
Extension->SetForwardAddress = TRUE;
}
}
//
// Do we need to enter a forward mode?
//
if ( (NT_SUCCESS(Status)) &&
(Extension->CurrentPhase != PHASE_FORWARD_IDLE) &&
(Extension->CurrentPhase != PHASE_FORWARD_XFER) &&
(afpForward[Extension->IdxForwardProtocol].fnEnterForward) ) {
Status = afpForward[Extension->IdxForwardProtocol].fnEnterForward(Extension);
}
ParDump2(PAREXIT, ( "ParReverseToForward: Exit [%d]\r\n", NT_SUCCESS(Status) ));
return Status;
}
NTSTATUS
ParSetFwdAddress(
IN PDEVICE_EXTENSION Extension
)
{
NTSTATUS Status = STATUS_SUCCESS;
ParDump2( PARENTRY, ("ParSetFwdAddress: Start: Channel [%x]\n", Extension->ForwardInterfaceAddress));
if (afpForward[Extension->IdxForwardProtocol].fnSetInterfaceAddress)
{
Status = ParReverseToForward(Extension);
if (!NT_SUCCESS(Status))
{
ParDump2(PARERRORS, ("ParSetFwdAddress: FAIL. Couldn't flip the bus for Set ECP/EPP Channel failed.\n") );
goto ParSetFwdAddress_ExitLabel;
}
Status = afpForward[Extension->IdxForwardProtocol].fnSetInterfaceAddress (
Extension,
Extension->ForwardInterfaceAddress);
if (NT_SUCCESS(Status))
Extension->SetForwardAddress = FALSE;
else
{
ParDump2(PARERRORS, ("ParSetFwdAddress: FAIL. Set ECP/EPP Channel failed.\n") );
goto ParSetFwdAddress_ExitLabel;
}
}
else
{
ParDump2(PARERRORS, ("ParSetFwdAddress: FAIL. Protocol doesn't support SetECP/EPP Channel\n") );
Status = STATUS_UNSUCCESSFUL;
goto ParSetFwdAddress_ExitLabel;
}
ParSetFwdAddress_ExitLabel:
return Status;
}
VOID
ParTerminate(
IN PDEVICE_EXTENSION Extension
)
{
if (!Extension->Connected)
return;
if (Extension->CurrentPhase == PHASE_REVERSE_IDLE ||
Extension->CurrentPhase == PHASE_REVERSE_XFER)
{
if (afpForward[Extension->IdxForwardProtocol].ProtocolFamily !=
arpReverse[Extension->IdxReverseProtocol].ProtocolFamily)
{
if (arpReverse[Extension->IdxReverseProtocol].fnDisconnect)
{
ParDump2(PARINFO, ("ParTerminate: Calling arpReverse.fnDisconnect\r\n"));
arpReverse[Extension->IdxReverseProtocol].fnDisconnect (Extension);
}
return;
}
ParReverseToForward(Extension);
}
if (afpForward[Extension->IdxForwardProtocol].fnDisconnect)
{
ParDump2(PARINFO, ("ParTerminate: Calling afpForward.fnDisconnect\r\n"));
afpForward[Extension->IdxForwardProtocol].fnDisconnect (Extension);
}
}
NTSTATUS
ParWrite(
IN PDEVICE_EXTENSION Extension,
OUT PVOID Buffer,
IN ULONG NumBytesToWrite,
OUT PULONG NumBytesWritten
)
{
NTSTATUS Status = STATUS_SUCCESS;
#if (1 == DVRH_RAISE_IRQL)
KIRQL OldIrql;
#endif
#if (1 == DVRH_RAISE_IRQL)
KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
#endif
// dvdr
ParDump2(PARINFO, ("ParWrite: Entering\n"));
//
// The routine which performs the write varies depending upon the currently
// negotiated mode. Start I/O moves the IRP into the Extension (CurrentOpIrp)
//
// Default mode: Centronics
//
// dvdr
ParDump2(PARINFO, ("ParWrite: Calling ParReverseToForward\n"));
// Go ahead and flip the bus if need be. The proc will just make sure we're properly
// connected and pointing in the right direction.
Status = ParReverseToForward( Extension );
// only do this if we are in safe mode
if ( Extension->ModeSafety == SAFE_MODE ) {
//
// Set the channel address if we need to.
//
if (NT_SUCCESS(Status) && Extension->SetForwardAddress &&
(afpForward[Extension->IdxForwardProtocol].fnSetInterfaceAddress))
{
// dvdr
ParDump2(PARINFO, ("ParWrite: Calling Protocol %x\n", Extension->IdxForwardProtocol));
Status = afpForward[Extension->IdxForwardProtocol].fnSetInterfaceAddress (
Extension,
Extension->ForwardInterfaceAddress);
if (NT_SUCCESS(Status))
Extension->SetForwardAddress = FALSE;
else
Extension->SetForwardAddress = TRUE;
}
}
if (NT_SUCCESS(Status)) {
#if (1 == DVRH_USE_CORRECT_PTRS)
if (Extension->fnWrite || afpForward[Extension->IdxForwardProtocol].fnWrite) {
#else
if (afpForward[Extension->IdxForwardProtocol].fnWrite) {
#endif
*NumBytesWritten = 0;
#if DVRH_SHOW_BYTE_LOG
{
ULONG i=0;
DbgPrint("Parallel:Write: ");
for (i=0; i<NumBytesToWrite; ++i) { DbgPrint(" %02x",*((PUCHAR)Buffer+i)); }
DbgPrint("\n");
}
#endif
#if (1 == DVRH_USE_CORRECT_PTRS)
if( Extension->fnWrite) {
Status = ((PPROTOCOL_WRITE_ROUTINE)Extension->fnWrite)(Extension,
Buffer,
NumBytesToWrite,
NumBytesWritten);
} else {
Status = afpForward[Extension->IdxForwardProtocol].fnWrite(Extension,
Buffer,
NumBytesToWrite,
NumBytesWritten);
}
#else
Status = afpForward[Extension->IdxForwardProtocol].fnWrite(Extension,
Buffer,
NumBytesToWrite,
NumBytesWritten);
#endif
}
#if DBG
else {
ParDump2(PARERRORS, ( "ParReadIrp: Don't have a fnWrite!\r\n" ));
ParDump2(PARERRORS, ( "ParReadIrp: You're hosed man.\r\n" ));
ParDump2(PARERRORS, ( "ParReadIrp: If you are here, you've got a bug somewhere else.\r\n" ));
ParDump2(PARERRORS, ( "ParReadIrp: Go fix it!\r\n" ));
}
#endif
}
#if DBG
else {
ParDump2(PARERRORS, ( "ParReadIrp: Failure from above! Didn't call Write!\r\n" ));
ParDump2(PARERRORS, ( "ParReadIrp: You're hosed man.\r\n" ));
ParDump2(PARERRORS, ( "ParReadIrp: If you are here, you've got a bug somewhere else.\r\n" ));
ParDump2(PARERRORS, ( "ParReadIrp: Go fix it!\r\n" ));
}
#endif
#if (1 == DVRH_RAISE_IRQL)
KeLowerIrql(OldIrql);
#endif
// dvdr
ParDump2(PARINFO, ("ParWrite: Leaving\n"));
return Status;
}
VOID
ParWriteIrp(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine implements a WRITE request with the extension's current irp.
Arguments:
Extension - Supplies the device extension.
Return Value:
None.
--*/
{
PIRP Irp;
PIO_STACK_LOCATION IrpSp;
ULONG NumBytesWritten = 0;
Irp = Extension->CurrentOpIrp;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
ParTimerCheck(( "ParWriteIrp: Start. BytesToWrite[%d]\r\n", IrpSp->Parameters.Write.Length ));
Irp->IoStatus.Status = ParWrite(Extension,
Irp->AssociatedIrp.SystemBuffer,
IrpSp->Parameters.Write.Length,
&NumBytesWritten);
Irp->IoStatus.Information = NumBytesWritten;
ParTimerCheck(( "ParWriteIrp: End. BytesWritten[%d]\r\n", NumBytesWritten ));
}
Reference in a new issue Copy permalink