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

898 lines
28 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"
NTSTATUS
ParForwardToReverse(
IN PPDO_EXTENSION Pdx
)
/*++
Routine Description:
This routine flips the bus from Forward to Reverse direction.
Arguments:
Pdx - 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( Pdx->Connected &&
( Pdx->CurrentPhase == PHASE_REVERSE_IDLE || Pdx->CurrentPhase == PHASE_REVERSE_XFER) ) {
DD((PCE)Pdx,DDT,"ParForwardToReverse - already in reverse mode\n");
return Status;
}
if (Pdx->Connected) {
if (Pdx->CurrentPhase != PHASE_REVERSE_IDLE &&
Pdx->CurrentPhase != PHASE_REVERSE_XFER) {
if (afpForward[Pdx->IdxForwardProtocol].ProtocolFamily ==
arpReverse[Pdx->IdxReverseProtocol].ProtocolFamily) {
// 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[Pdx->IdxForwardProtocol].fnExitForward) ) {
Status = afpForward[Pdx->IdxForwardProtocol].fnExitForward(Pdx);
}
} else {
//
// Protocol Families don't match...need to terminate from the forward mode
//
if (afpForward[Pdx->IdxForwardProtocol].fnDisconnect) {
afpForward[Pdx->IdxForwardProtocol].fnDisconnect (Pdx);
}
if ((Pdx->ForwardInterfaceAddress != DEFAULT_ECP_CHANNEL) &&
(afpForward[Pdx->IdxForwardProtocol].fnSetInterfaceAddress))
Pdx->SetForwardAddress = TRUE;
}
}
}
if( (!Pdx->Connected) && (arpReverse[Pdx->IdxReverseProtocol].fnConnect) ) {
//
// If we are still connected the protocol families match...
//
Status = arpReverse[Pdx->IdxReverseProtocol].fnConnect(Pdx, FALSE);
//
// Makes the assumption that the connected address is always 0
//
if ((NT_SUCCESS(Status)) &&
(arpReverse[Pdx->IdxReverseProtocol].fnSetInterfaceAddress) &&
(Pdx->ReverseInterfaceAddress != DEFAULT_ECP_CHANNEL)) {
Pdx->SetReverseAddress = TRUE;
}
}
//
// Set the channel address if we need to.
//
if (NT_SUCCESS(Status) && Pdx->SetReverseAddress &&
(arpReverse[Pdx->IdxReverseProtocol].fnSetInterfaceAddress)) {
Status = arpReverse[Pdx->IdxReverseProtocol].fnSetInterfaceAddress (
Pdx,
Pdx->ReverseInterfaceAddress);
if (NT_SUCCESS(Status))
Pdx->SetReverseAddress = FALSE;
else
Pdx->SetReverseAddress = TRUE;
}
//
// Do we need to reverse?
//
if ( (NT_SUCCESS(Status)) &&
((Pdx->CurrentPhase != PHASE_REVERSE_IDLE) &&
(Pdx->CurrentPhase != PHASE_REVERSE_XFER)) ) {
if ((arpReverse[Pdx->IdxReverseProtocol].fnEnterReverse))
Status = arpReverse[Pdx->IdxReverseProtocol].fnEnterReverse(Pdx);
}
DD((PCE)Pdx,DDT,"ParForwardToReverse - exit w/status=%x\n",Status);
return Status;
}
BOOLEAN
ParHaveReadData(
IN PPDO_EXTENSION Pdx
)
/*++
Routine Description:
This method determines if the dot4 peripheral has any data ready
to send to the host.
Arguments:
Pdx - Supplies the device EXTENSION.
Return Value:
TRUE - Either the peripheral has data
FALSE - No data
--*/
{
NTSTATUS status;
BOOLEAN justAcquiredPort = FALSE;
if( Pdx->CurrentPhase != PHASE_TERMINATE &&
Pdx->CurrentPhase != PHASE_REVERSE_IDLE &&
Pdx->CurrentPhase != PHASE_REVERSE_XFER &&
Pdx->CurrentPhase != PHASE_FORWARD_IDLE &&
Pdx->CurrentPhase != PHASE_FORWARD_XFER ) {
// unexpected phase - no idea what to do here - pretend that
// there is no data avail and return
DD((PCE)Pdx,DDE,"ParHaveReadData - unexpected CurrentPhase %x\n",Pdx->CurrentPhase);
PptAssertMsg("ParHaveReadData - unexpected CurrentPhase",FALSE);
return FALSE;
}
if( PHASE_TERMINATE == Pdx->CurrentPhase ) {
//
// we're not currently talking with the peripheral and we
// likely don't have access to the port - try to acquire the
// port and establish communication with the peripheral so
// that we can check if the peripheral has data for us
//
// CurrentPhase indicates !Connected - do a check for consistency
PptAssert( !Pdx->Connected );
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_TERMINATE\n");
if( !Pdx->bAllocated ) {
// we don't have the port - try to acquire port
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_TERMINATE - don't have port\n");
status = PptAcquirePortViaIoctl( Pdx->Fdo, NULL );
if( STATUS_SUCCESS == status ) {
// we now have the port
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_TERMINATE - port acquired\n");
// note that we have just now acquired the port so
// that we can release the port below if we are unable
// to establish communication with the peripheral
justAcquiredPort = TRUE;
Pdx->bAllocated = TRUE;
} else {
// we couldn't get the port - bail out
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_TERMINATE - don't have port - acquire failed\n");
return FALSE;
}
} // endif !Pdx->bAllocated
//
// we now have the port - try to negotiate into a forward
// mode since we believe that the check for periph data
// avail is more robust in forward modes
//
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_TERMINATE - we have the port - try to Connect\n");
DD((PCE)Pdx,DDE,"ParHaveReadData - we have the port - try to Connect - calling ParReverseToForward\n");
//
// ParReverseToForward:
//
// 1) tries to negotiate the peripheral into the forward mode
// specified by a combination of the device specific
// Pdx->IdxForwardProtocol and the driver global afpForward
// array.
//
// 2) sets up our internal state machine, Pdx->CurrentPhase
//
// 3) as a side effect - sets Pdx->SetForwardAddress if we
// need to use a non-Zero ECP (or EPP) address.
//
status = ParReverseToForward( Pdx );
if( STATUS_SUCCESS == status ) {
//
// We are in communication with the peripheral
//
DD((PCE)Pdx,DDE,"ParHaveReadData - we have the port - connected - ParReverseToForward SUCCESS\n");
// Set the channel address if we need to - use the side effect from ParReverseToForward here
if( Pdx->SetForwardAddress ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - we have the port - connected - try to set Forward Address\n");
if( afpForward[Pdx->IdxForwardProtocol].fnSetInterfaceAddress ) {
status = afpForward[Pdx->IdxForwardProtocol].fnSetInterfaceAddress ( Pdx, Pdx->ForwardInterfaceAddress );
if( STATUS_SUCCESS == status ) {
// success - set flag to indicate that we don't need to set the address again
DD((PCE)Pdx,DDE,"ParHaveReadData - we have the port - connected - set Forward Address - SUCCESS\n");
Pdx->SetForwardAddress = FALSE;
} else {
// couldn't set address - clean up and bail out - report no peripheral data avail
DD((PCE)Pdx,DDE,"ParHaveReadData - we have the port - connected - set Forward Address - FAIL\n");
Pdx->SetForwardAddress = TRUE;
// Return peripheral to quiescent state
// (Compatibility Mode Forward Idle) and set
// our state machine accordingly
ParTerminate( Pdx );
// if we just acquired the port in this function then give
// up the port, otherwise keep it for now
if( justAcquiredPort ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - set address failed - giving up port\n");
ParFreePort( Pdx );
}
return FALSE;
}
}
} else {
DD((PCE)Pdx,DDE,"ParHaveReadData - we have the port - connected - no need to set Forward Address\n");
}
} else {
// unable to establish communication with peripheral
DD((PCE)Pdx,DDE,"ParHaveReadData - we have the port - try to Connect - ParReverseToForward FAILED\n");
// if we just acquired the port in this function then give
// up the port, otherwise keep it for now
if( justAcquiredPort ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - connect failed - giving up port\n");
ParFreePort( Pdx );
}
return FALSE;
}
// we're communicating with the peripheral - fall through to below to check for data avail
} // endif PHASE_TERMINATE == CurrentPhase
if( Pdx->CurrentPhase == PHASE_REVERSE_IDLE ||
Pdx->CurrentPhase == PHASE_REVERSE_XFER ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_REVERSE_*\n");
if( arpReverse[Pdx->IdxReverseProtocol].fnHaveReadData ) {
if( arpReverse[Pdx->IdxReverseProtocol].fnHaveReadData( Pdx ) ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_REVERSE_* - we have data\n");
return TRUE;
}
}
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_REVERSE_* - no data - flip bus to forward\n");
// Don't have data. This could be a fluke. Let's flip the bus
// and try again in Fwd mode since some peripherals reportedly
// have broken firmware that does not properly signal that
// they have data avail when in some reverse modes.
ParReverseToForward( Pdx );
}
if( Pdx->CurrentPhase == PHASE_FORWARD_IDLE ||
Pdx->CurrentPhase == PHASE_FORWARD_XFER ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_FORWARD_*\n");
if( afpForward[Pdx->IdxForwardProtocol].ProtocolFamily == FAMILY_BECP ||
afpForward[Pdx->IdxForwardProtocol].Protocol & ECP_HW_NOIRQ ||
afpForward[Pdx->IdxForwardProtocol].Protocol & ECP_HW_IRQ) {
if( PptEcpHwHaveReadData( Pdx ) ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_FORWARD_* - ECP HW - have data\n");
return TRUE;
}
// Hmmm. No data. Is the chip stuck?
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_FORWARD_* - ECP HW - no data\n");
return FALSE;
} else {
if( afpForward[Pdx->IdxForwardProtocol].Protocol & ECP_SW ) {
DD((PCE)Pdx,DDE,"ParHaveReadData - PHASE_FORWARD_* - ECP SW - checking for data\n");
return ParEcpHaveReadData( Pdx );
}
}
}
// DVRH RMT
// We got here because the protocol doesn't support peeking.
// - pretend there is data avail
DD((PCE)Pdx,DDE,"ParHaveReadData - exit - returning TRUE\n");
return TRUE;
}
NTSTATUS
ParPing(
IN PPDO_EXTENSION Pdx
)
/*++
Routine Description:
This method was intended to ping the device, but it is currently a NOOP.
Arguments:
Pdx - Supplies the device EXTENSION.
Return Value:
none
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
UNREFERENCED_PARAMETER( Pdx );
return NtStatus;
}
NTSTATUS
PptPdoReadWrite(
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;
PPDO_EXTENSION Pdx;
Irp->IoStatus.Information = 0;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
Pdx = DeviceObject->DeviceExtension;
//
// bail out if a delete is pending for this device object
//
if(Pdx->DeviceStateFlags & PPT_DEVICE_DELETE_PENDING) {
return P4CompleteRequest( Irp, STATUS_DELETE_PENDING, Irp->IoStatus.Information );
}
//
// bail out if a remove is pending for our ParPort device object
//
if(Pdx->DeviceStateFlags & PAR_DEVICE_PORT_REMOVE_PENDING) {
return P4CompleteRequest( Irp, STATUS_DELETE_PENDING, Irp->IoStatus.Information );
}
//
// bail out if device has been removed
//
if(Pdx->DeviceStateFlags & (PPT_DEVICE_REMOVED|PPT_DEVICE_SURPRISE_REMOVED) ) {
return P4CompleteRequest( Irp, STATUS_DEVICE_REMOVED, Irp->IoStatus.Information );
}
//
// 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) ) {
return P4CompleteRequest( Irp, STATUS_INVALID_PARAMETER, Irp->IoStatus.Information );
}
//
// immediately succeed read or write request of length zero
//
if (IrpSp->Parameters.Write.Length == 0) {
return P4CompleteRequest( Irp, STATUS_SUCCESS, Irp->IoStatus.Information );
}
//
// 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( &Pdx->WorkQueue ) ? TRUE : FALSE;
#pragma warning( push )
#pragma warning( disable : 4054 4055 )
IoSetCancelRoutine(Irp, ParCancelRequest);
#pragma warning( pop )
IoMarkIrpPending(Irp);
InsertTailList(&Pdx->WorkQueue, &Irp->Tail.Overlay.ListEntry);
IoReleaseCancelSpinLock(OldIrql);
if( needToSignalSemaphore ) {
KeReleaseSemaphore(&Pdx->RequestSemaphore, 0, 1, FALSE);
}
return STATUS_PENDING;
}
}
}
NTSTATUS
ParRead(
IN PPDO_EXTENSION Pdx,
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;
*NumBytesRead = Bytes;
// only do this if we are in safe mode
if ( Pdx->ModeSafety == SAFE_MODE ) {
if (arpReverse[Pdx->IdxReverseProtocol].fnReadShadow) {
Queue *pQueue;
pQueue = &(Pdx->ShadowBuffer);
arpReverse[Pdx->IdxReverseProtocol].fnReadShadow( pQueue, lpsBufPtr, NumBytesToRead, &Bytes );
NumBytesToRead -= Bytes;
*NumBytesRead += Bytes;
lpsBufPtr += Bytes;
if ( 0 == NumBytesToRead ) {
Status = STATUS_SUCCESS;
if ((!Queue_IsEmpty(pQueue)) &&
(TRUE == Pdx->P12843DL.bEventActive) ) {
KeSetEvent(Pdx->P12843DL.Event, 0, FALSE);
}
goto ParRead_ExitLabel;
}
}
if (arpReverse[Pdx->IdxReverseProtocol].fnHaveReadData) {
if (!arpReverse[Pdx->IdxReverseProtocol].fnHaveReadData(Pdx)) {
DD((PCE)Pdx,DDT,"ParRead - periph doesn't have data - give cycles to someone else\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( Pdx );
//
// The read mode will vary depending upon the currently negotiated mode.
// Default: Nibble
//
if (NT_SUCCESS(Status)) {
if (Pdx->fnRead || arpReverse[Pdx->IdxReverseProtocol].fnRead) {
//
// Do the read...
//
if(Pdx->fnRead) {
Status = ((PPROTOCOL_READ_ROUTINE)Pdx->fnRead)( Pdx, (PVOID)lpsBufPtr, NumBytesToRead, &Bytes );
} else {
Status = arpReverse[Pdx->IdxReverseProtocol].fnRead( Pdx, (PVOID)lpsBufPtr, NumBytesToRead, &Bytes );
}
*NumBytesRead += Bytes;
NumBytesToRead -= Bytes;
#if DVRH_SHOW_BYTE_LOG
{
ULONG i=0;
DD((PCE)Pdx,DDT,"Parallel:Read: ");
for (i=0; i<*NumBytesRead; ++i) {
DD((PCE)Pdx,DDT," %02x",((PUCHAR)lpsBufPtr)[i]);
}
DD((PCE)Pdx,DDT,"\n");
}
#endif
} else {
// If you are here, you've got a bug somewhere else
DD((PCE)Pdx,DDE,"ParRead - you're hosed man - no fnRead\n");
PptAssertMsg("ParRead - don't have a fnRead! Can't Read!\n",FALSE);
}
} else {
DD((PCE)Pdx,DDE,"ParRead - Bus Flip Forward->Reverse FAILED - can't read\n");
}
ParRead_ExitLabel:
return Status;
}
VOID
ParReadIrp(
IN PPDO_EXTENSION Pdx
)
/*++
Routine Description:
This routine implements a READ request with the extension's current irp.
Arguments:
Pdx - Supplies the device extension.
Return Value:
None.
--*/
{
PIRP Irp = Pdx->CurrentOpIrp;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
ULONG bytesRead;
NTSTATUS status;
status = ParRead( Pdx, Irp->AssociatedIrp.SystemBuffer, IrpSp->Parameters.Read.Length, &bytesRead );
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = bytesRead;
DD((PCE)Pdx,DDT,"ParReadIrp - status = %x, bytesRead=%d\n", status, bytesRead);
return;
}
NTSTATUS
ParReverseToForward(
IN PPDO_EXTENSION Pdx
)
/*++
Routine Description:
This routine flips the bus from Reverse to Forward direction.
Arguments:
Pdx - Supplies the device extension.
Return Value:
None.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
// dvdr
if (Pdx->Connected) {
// Do a quick check to see if we are where we want to be.
// Happy punt if everything is ok.
if( Pdx->CurrentPhase == PHASE_FORWARD_IDLE || Pdx->CurrentPhase == PHASE_FORWARD_XFER ) {
DD((PCE)Pdx,DDT,"ParReverseToForward: Already in Fwd. Exit STATUS_SUCCESS\n");
return Status;
} else {
if (afpForward[Pdx->IdxForwardProtocol].ProtocolFamily !=
arpReverse[Pdx->IdxReverseProtocol].ProtocolFamily) {
//
// Protocol Families don't match...need to terminate from the forward mode
//
if (arpReverse[Pdx->IdxReverseProtocol].fnDisconnect) {
arpReverse[Pdx->IdxReverseProtocol].fnDisconnect (Pdx);
}
if ((Pdx->ReverseInterfaceAddress != DEFAULT_ECP_CHANNEL) &&
(arpReverse[Pdx->IdxReverseProtocol].fnSetInterfaceAddress)) {
Pdx->SetReverseAddress = TRUE;
}
} else if((Pdx->CurrentPhase == PHASE_REVERSE_IDLE) || (Pdx->CurrentPhase == PHASE_REVERSE_XFER)) {
if ( (arpReverse[Pdx->IdxReverseProtocol].fnExitReverse) ) {
Status = arpReverse[Pdx->IdxReverseProtocol].fnExitReverse(Pdx);
}
} else {
// We are in a screwy state.
DD((PCE)Pdx,DDE,"ParReverseToForward: We're lost! Unknown state - Gonna start spewing!\n");
Status = STATUS_IO_TIMEOUT; // I picked a RetVal from thin air!
}
}
}
// Yes, we still want to check for connection since we might have
// terminated in the previous code block!
if (!Pdx->Connected && afpForward[Pdx->IdxForwardProtocol].fnConnect) {
Status = afpForward[Pdx->IdxForwardProtocol].fnConnect( Pdx, FALSE );
//
// Makes the assumption that the connected address is always 0
//
if ((NT_SUCCESS(Status)) && (Pdx->ForwardInterfaceAddress != DEFAULT_ECP_CHANNEL)) {
Pdx->SetForwardAddress = TRUE;
}
}
//
// Do we need to enter a forward mode?
//
if ( (NT_SUCCESS(Status)) &&
(Pdx->CurrentPhase != PHASE_FORWARD_IDLE) &&
(Pdx->CurrentPhase != PHASE_FORWARD_XFER) &&
(afpForward[Pdx->IdxForwardProtocol].fnEnterForward) ) {
Status = afpForward[Pdx->IdxForwardProtocol].fnEnterForward(Pdx);
}
DD((PCE)Pdx,DDT,"ParReverseToForward - exit w/status= %x\n", Status);
return Status;
}
NTSTATUS
ParSetFwdAddress(
IN PPDO_EXTENSION Pdx
)
{
NTSTATUS Status = STATUS_SUCCESS;
DD((PCE)Pdx,DDT,"ParSetFwdAddress: Start: Channel [%x]\n", Pdx->ForwardInterfaceAddress);
if (afpForward[Pdx->IdxForwardProtocol].fnSetInterfaceAddress) {
Status = ParReverseToForward(Pdx);
if (!NT_SUCCESS(Status)) {
DD((PCE)Pdx,DDE,"ParSetFwdAddress: FAIL. Couldn't flip the bus for Set ECP/EPP Channel failed.\n");
goto ParSetFwdAddress_ExitLabel;
}
Status = afpForward[Pdx->IdxForwardProtocol].fnSetInterfaceAddress (
Pdx,
Pdx->ForwardInterfaceAddress);
if (NT_SUCCESS(Status)) {
Pdx->SetForwardAddress = FALSE;
} else {
DD((PCE)Pdx,DDE,"ParSetFwdAddress: FAIL. Set ECP/EPP Channel failed.\n");
goto ParSetFwdAddress_ExitLabel;
}
} else {
DD((PCE)Pdx,DDE,"ParSetFwdAddress: FAIL. Protocol doesn't support SetECP/EPP Channel\n");
Status = STATUS_UNSUCCESSFUL;
goto ParSetFwdAddress_ExitLabel;
}
ParSetFwdAddress_ExitLabel:
return Status;
}
VOID
ParTerminate(
IN PPDO_EXTENSION Pdx
)
{
if (!Pdx->Connected) {
return;
}
if (Pdx->CurrentPhase == PHASE_REVERSE_IDLE || Pdx->CurrentPhase == PHASE_REVERSE_XFER) {
if (afpForward[Pdx->IdxForwardProtocol].ProtocolFamily !=
arpReverse[Pdx->IdxReverseProtocol].ProtocolFamily) {
if (arpReverse[Pdx->IdxReverseProtocol].fnDisconnect) {
DD((PCE)Pdx,DDT,"ParTerminate: Calling arpReverse.fnDisconnect\r\n");
arpReverse[Pdx->IdxReverseProtocol].fnDisconnect (Pdx);
}
return;
}
ParReverseToForward(Pdx);
}
if (afpForward[Pdx->IdxForwardProtocol].fnDisconnect) {
DD((PCE)Pdx,DDT,"ParTerminate: Calling afpForward.fnDisconnect\r\n");
afpForward[Pdx->IdxForwardProtocol].fnDisconnect (Pdx);
}
}
NTSTATUS
ParWrite(
IN PPDO_EXTENSION Pdx,
OUT PVOID Buffer,
IN ULONG NumBytesToWrite,
OUT PULONG NumBytesWritten
)
{
NTSTATUS Status = STATUS_SUCCESS;
//
// The routine which performs the write varies depending upon the currently
// negotiated mode. Start I/O moves the IRP into the Pdx (CurrentOpIrp)
//
// Default mode: Centronics
//
// 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( Pdx );
// only do this if we are in safe mode
if ( Pdx->ModeSafety == SAFE_MODE ) {
//
// Set the channel address if we need to.
//
if (NT_SUCCESS(Status) && Pdx->SetForwardAddress &&
(afpForward[Pdx->IdxForwardProtocol].fnSetInterfaceAddress))
{
Status = afpForward[Pdx->IdxForwardProtocol].fnSetInterfaceAddress (
Pdx,
Pdx->ForwardInterfaceAddress);
if (NT_SUCCESS(Status))
Pdx->SetForwardAddress = FALSE;
else
Pdx->SetForwardAddress = TRUE;
}
}
if (NT_SUCCESS(Status)) {
if (Pdx->fnWrite || afpForward[Pdx->IdxForwardProtocol].fnWrite) {
*NumBytesWritten = 0;
#if DVRH_SHOW_BYTE_LOG
{
ULONG i=0;
DD((PCE)Pdx,DDT,"Parallel:Write: ");
for (i=0; i<NumBytesToWrite; ++i) {
DD((PCE)Pdx,DDT," %02x",*((PUCHAR)Buffer+i));
}
DD((PCE)Pdx,DDT,"\n");
}
#endif
if( Pdx->fnWrite) {
Status = ((PPROTOCOL_WRITE_ROUTINE)Pdx->fnWrite)(Pdx,
Buffer,
NumBytesToWrite,
NumBytesWritten);
} else {
Status = afpForward[Pdx->IdxForwardProtocol].fnWrite(Pdx,
Buffer,
NumBytesToWrite,
NumBytesWritten);
}
}
}
return Status;
}
VOID
ParWriteIrp(
IN PPDO_EXTENSION Pdx
)
/*++
Routine Description:
This routine implements a WRITE request with the extension's current irp.
Arguments:
Pdx - Supplies the device extension.
Return Value:
None.
--*/
{
PIRP Irp;
PIO_STACK_LOCATION IrpSp;
ULONG NumBytesWritten = 0;
Irp = Pdx->CurrentOpIrp;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
Irp->IoStatus.Status = ParWrite(Pdx,
Irp->AssociatedIrp.SystemBuffer,
IrpSp->Parameters.Write.Length,
&NumBytesWritten);
Irp->IoStatus.Information = NumBytesWritten;
}
Reference in a new issue Copy permalink