archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/drivers/parallel/parclass/ieee1284.c

940 lines
30 KiB
Raw Blame History

/*++
Copyright (C) Microsoft Corporation, 1993 - 1999
Module Name:
ieee1284.c
Abstract:
This module contains the code to do ieee 1284 negotiation and termination.
Author:
Timothy T. Wells (v-timtw) 13 Mar 97
Robbie Harris (Hewlett-Packard) 21 May 98. Added enough comments to the
Negotation proc to keep any developer happy.
Environment:
Kernel mode
Revision History :
--*/
#include "pch.h"
#include "readwrit.h"
VOID
IeeeTerminate1284Mode(
IN PDEVICE_EXTENSION Extension
);
NTSTATUS
IeeeEnter1284Mode(
IN PDEVICE_EXTENSION Extension,
IN UCHAR Extensibility
);
//
// Definition of the Forward and Reverse Protocol Arrays
//
extern FORWARD_PTCL afpForward[] = {
//
// Bounded ECP (Hardware)
//
ParIsBecpSupported,
ParEnterBecpMode,
ParTerminateBecpMode,
ParEcpHwSetAddress,
ParEcpEnterForwardPhase, // Enter Forward
ParEcpHwExitForwardPhase, // Exit Forward
ParEcpHwWrite,
BOUNDED_ECP,
FAMILY_BECP,
//
// ECP Hardware
//
ParIsEcpHwSupported, // This is resued for both read/write
ParEnterEcpHwMode,
ParTerminateHwEcpMode,
ParEcpHwSetAddress,
ParEcpEnterForwardPhase, // Enter Forward
ParEcpHwExitForwardPhase, // Exit Forward
ParEcpHwWrite,
ECP_HW_NOIRQ,
FAMILY_ECP,
//
// Epp Hardware
//
ParIsEppHwSupported,
ParEnterEppHwMode,
ParTerminateEppHwMode,
ParEppSetAddress,
NULL, // Enter Forward
NULL, // Exit Forward
ParEppHwWrite,
EPP_HW,
FAMILY_EPP,
//
// Epp Software
//
ParIsEppSwWriteSupported,
ParEnterEppSwMode,
ParTerminateEppSwMode,
ParEppSetAddress,
NULL, // Enter Forward
NULL, // Exit Forward
ParEppSwWrite,
EPP_SW,
FAMILY_EPP,
//
// Ecp Software
//
ParIsEcpSwWriteSupported,
ParEnterEcpSwMode,
ParTerminateEcpMode,
ParEcpSetAddress,
NULL, // Enter Forward
NULL, // Exit Forward
ParEcpSwWrite,
ECP_SW,
FAMILY_ECP,
//
// IEEE Centronics
//
NULL,
ParEnterSppMode,
ParTerminateSppMode,
NULL,
NULL, // Enter Forward
NULL, // Exit Forward
SppIeeeWrite,
IEEE_COMPATIBILITY,
FAMILY_NONE,
//
// Centronics
//
NULL,
ParEnterSppMode,
ParTerminateSppMode,
NULL,
NULL, // Enter Forward
NULL, // Exit Forward
SppWrite,
CENTRONICS,
FAMILY_NONE,
//
// None...
//
NULL,
NULL,
NULL,
NULL,
NULL, // Enter Forward
NULL, // Exit Forward
NULL,
NONE,
FAMILY_NONE
};
extern REVERSE_PTCL arpReverse[] = {
//
// Bounded Ecp Mode
//
ParIsBecpSupported,
ParEnterBecpMode,
ParTerminateBecpMode,
NULL, // Violates IEEE 1284.3 to set Reverse address for BECP
ParEcpHwEnterReversePhase, // Enter Reverse
ParBecpExitReversePhase, // Exit Reverse
ParEcpHwDrainShadowBuffer, // A read from Cached data
ParEcpHwHaveReadData, // Quick peek to see if Periph has reverse data without flipping the bus
// NOTE: This is crucial since it violates the 1284.3 BECP to flip
// blindly into reverse if the peripheral doesn't have data.
ParBecpRead,
BOUNDED_ECP,
FAMILY_BECP,
//
// Hardware Ecp Mode
//
ParIsEcpHwSupported, // This is resued for both read/write
ParEnterEcpHwMode,
ParTerminateHwEcpMode,
ParEcpHwSetAddress, // Reuse the one in ecp.c
ParEcpHwEnterReversePhase, // Enter Reverse
ParEcpHwExitReversePhase, // Exit Reverse
ParEcpHwDrainShadowBuffer, // A read from Cached data
ParEcpHwHaveReadData, // Quick peek to see if Periph has reverse data without flipping the bus
ParEcpHwRead,
ECP_HW_NOIRQ,
FAMILY_ECP,
//
// Epp Hardware
//
ParIsEppHwSupported, // This is resued for both read/write
ParEnterEppHwMode,
ParTerminateEppHwMode,
ParEppSetAddress,
NULL, // Enter Reverse
NULL, // Exit Reverse
NULL, // A read from Cached data
NULL, // Quick peek to see if Periph has reverse data without flipping the bus
ParEppHwRead,
EPP_HW,
FAMILY_EPP,
//
// Epp Software Mode
//
ParIsEppSwReadSupported,
ParEnterEppSwMode,
ParTerminateEppSwMode,
ParEppSetAddress,
NULL, // Enter Reverse
NULL, // Exit Reverse
NULL, // A read from Cached data
NULL, // Quick peek to see if Periph has reverse data without flipping the bus
ParEppSwRead,
EPP_SW,
FAMILY_EPP,
//
// Ecp Software Mode
//
ParIsEcpSwReadSupported,
ParEnterEcpSwMode,
ParTerminateEcpMode,
ParEcpSetAddress,
ParEcpForwardToReverse, // Enter Reverse
ParEcpReverseToForward, // Exit Reverse
NULL, // A read from Cached data
ParEcpHaveReadData, // Quick peek to see if Periph has reverse data without flipping the bus
ParEcpSwRead,
ECP_SW,
FAMILY_ECP,
//
// Byte Mode
//
ParIsByteSupported,
ParEnterByteMode,
ParTerminateByteMode,
NULL,
NULL, // Enter Reverse
NULL, // Exit Reverse
NULL, // A read from Cached data
NULL, // Quick peek to see if Periph has reverse data without flipping the bus
ParByteModeRead,
BYTE_BIDIR,
FAMILY_REVERSE_BYTE,
//
// Nibble Mode
//
ParIsNibbleSupported,
ParEnterNibbleMode,
ParTerminateNibbleMode,
NULL,
NULL, // Enter Reverse
NULL, // Exit Reverse
NULL, // A read from Cached data
NULL, // Quick peek to see if Periph has reverse data without flipping the bus
ParNibbleModeRead,
NIBBLE,
FAMILY_REVERSE_NIBBLE,
//
// Channelized Nibble Mode
//
ParIsChannelizedNibbleSupported,
ParEnterChannelizedNibbleMode,
ParTerminateNibbleMode,
NULL,
NULL, // Enter Reverse
NULL, // Exit Reverse
NULL, // A read from Cached data
NULL, // Quick peek to see if Periph has reverse data without flipping the bus
ParNibbleModeRead,
CHANNEL_NIBBLE,
FAMILY_REVERSE_NIBBLE,
//
// None...
//
NULL,
NULL,
NULL,
NULL,
NULL, // Enter Reverse
NULL, // Exit Reverse
NULL, // A read from Cached data
NULL, // Quick peek to see if Periph has reverse data without flipping the bus
NULL,
NONE,
FAMILY_NONE
};
VOID
IeeeTerminate1284Mode(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine terminates the interface back to compatibility mode.
Arguments:
Controller - Supplies the parallel port's controller address.
Return Value:
None.
--*/
{
PUCHAR Controller;
PUCHAR wPortDCR;
UCHAR dcr, dsrMask, dsrValue;
BOOLEAN bXFlag;
BOOLEAN bUseXFlag = FALSE;
Controller = Extension->Controller;
wPortDCR = Controller + OFFSET_DCR;
dcr = READ_PORT_UCHAR(wPortDCR);
if ( PHASE_TERMINATE == Extension->CurrentPhase )
{
// We are already terminated. This will fail if we don't
// just bypass this mess.
goto Terminate_ExitLabel;
}
#if 0
// Not ready for this yet. --dvrh
if (!Extension->IsIeeeTerminateOk)
goto Terminate_ExitLabel;
#endif
// Keep Negotiated XFLAG to use for termination.
// xFlag, // Technically we should have
// cached this value from state
// 6 of nego. This peripheral's XFlag
// at pre state 22 should be the
// same as state 6.
bXFlag = READ_PORT_UCHAR(Controller + OFFSET_DSR) & 0x10;
// REVISIT: Do we need to ensure the preceeding state is a valid
// state to terminate from. In other words, is there there
// a black bar on the 1284 line for that state?
ParDump2(PARENTRY,("IeeeTerminate1284Mode: Start Controller %x\n", Controller));
// =============== Host State 22 Termination ===============8
// DIR = Don't Care (Possibly Low)
// IRQEN = Don't Care (Possibly Low)
// 1284/SelectIn = Low (Signals state 22)
// nReverseReq/**(ECP only) = Don't Care (High for ECP, otherwise unused)
// HostAck/HostBusy/nAutoFeed = High
// HostClk/nStrobe = High
//
Extension->CurrentEvent = 22;
dcr = READ_PORT_UCHAR(wPortDCR);
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, INACTIVE, DONT_CARE, ACTIVE, ACTIVE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
// Clear data lines so we don't have any random spew.
WRITE_PORT_UCHAR(Controller + OFFSET_DATA, 0);
// *************** Periph State 23/24 Termination ***************8
// PeriphAck/PtrBusy = High (Signals state 23 for ECP
// otherwise already high)
// PeriphClk/PtrClk = Low (Signals state 24 for ecp
// Signals state 23 for Nibble)
// nAckRev/AckDataReq/PE = Don't Care
// XFlag = Low (ECP and Byte) (State 24)
// = High (Nibble) (State 24)
// = Low (All DeviceID Requests including Nibble) (State 24)
// = Undefined (EPP)
// nPeriphReq/nDataAvail = High
// Don't check nPeriphReq/nDataAvail
// Since it was in a "Don't Care"
// state (ie. Double bar in the spec)
// until state 23 for ECP mode.
if (Extension->CurrentPhase == PHASE_REVERSE_IDLE ||
Extension->CurrentPhase == PHASE_REVERSE_XFER)
{
// We must be in Nibble Reverse. Let's double check!!!
if (FAMILY_REVERSE_NIBBLE == arpReverse[Extension->IdxReverseProtocol].ProtocolFamily ||
FAMILY_REVERSE_BYTE == arpReverse[Extension->IdxReverseProtocol].ProtocolFamily)
bUseXFlag = TRUE; // We're in Nibble or Byte
else
bUseXFlag = FALSE; // Don't know what mode we are in?
}
else
{
if (FAMILY_BECP == afpForward[Extension->IdxForwardProtocol].ProtocolFamily ||
FAMILY_ECP == afpForward[Extension->IdxForwardProtocol].ProtocolFamily)
bUseXFlag = TRUE; // We're in an ECP Flavor
else
bUseXFlag = FALSE; // Don't know what mode we are in?
}
if (bUseXFlag)
{
dsrMask = DSR_TEST_MASK( DONT_CARE,
INACTIVE,
DONT_CARE,
bXFlag ? INACTIVE : ACTIVE,
DONT_CARE );
dsrValue = DSR_TEST_VALUE( DONT_CARE,
INACTIVE,
DONT_CARE,
bXFlag ? INACTIVE : ACTIVE,
DONT_CARE );
}
else
{
dsrMask = DSR_TEST_MASK( DONT_CARE,
INACTIVE,
DONT_CARE,
DONT_CARE,
DONT_CARE );
dsrValue = DSR_TEST_VALUE( DONT_CARE,
INACTIVE,
DONT_CARE,
DONT_CARE,
DONT_CARE );
}
Extension->CurrentEvent = 23;
if (!CheckPort(Controller + OFFSET_DSR,
dsrMask,
dsrValue,
IEEE_MAXTIME_TL))
{
// We couldn't negotiate back to compatibility mode.
// just terminate.
ParDump2(PARERRORS,("IeeeTerminate1284Mode:State 23/24 Failed: Controller %x dsr %x dcr %x\n",
Controller,
READ_PORT_UCHAR(Controller + OFFSET_DSR), dcr));
goto Terminate_ExitLabel;
}
// =============== Host State 25 Termination ===============8
// DIR = Don't Care (Possibly Low)
// IRQEN = Don't Care (Possibly Low)
// 1284/SelectIn = Low
// nReverseReq/**(ECP only) = Don't Care (Possibly High)
// HostAck/HostBusy/nAutoFeed = Low (Signals State 25)
// HostClk/nStrobe = High
//
Extension->CurrentEvent = 25;
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, INACTIVE, DONT_CARE, INACTIVE, ACTIVE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
// =============== State 26 Termination ===============8
// Do nothing for state 26
// =============== Periph State 27 Termination ===============8
// PeriphAck/PtrBusy = High
// PeriphClk/PtrClk = High (Signals State 27)
// nAckRev/AckDataReq/PE = Don't Care (Invalid from State 23)
// XFlag = Don't Care (All Modes) (Invlaid at State 27)
// nPeriphReq/nDataAvial = Don't Care (Invalid from State 26)
// dvrh 6/16/97
Extension->CurrentEvent = 27;
if (!CHECK_DSR(Controller,
ACTIVE, ACTIVE, DONT_CARE, DONT_CARE, DONT_CARE,
IEEE_MAXTIME_TL))
{
ParDump2(PARERRORS, ("IeeeTerminate1284Mode:State 27 Failed: Controller %x dsr %x dcr %x\n",
Controller,
READ_PORT_UCHAR(Controller + OFFSET_DSR), dcr));
}
// I'm really big into having one exit point in a
// proc. 2/10/97 dvrh
Terminate_ExitLabel:
// =============== Host State 28 Termination ===============8
// DIR = Don't Care (Possibly Low)
// IRQEN = Don't Care (Possibly Low)
// 1284/SelectIn = Low
// nReverseReq/**(ECP only) = Don't Care (Possibly High)
// HostAck/HostBusy/nAutoFeed = High (Signals State 28)
// HostClk/nStrobe = High
//
Extension->CurrentEvent = 28;
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, INACTIVE, DONT_CARE, ACTIVE, ACTIVE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
// We are now back in compatibility mode.
ParDump2(PARECPTRACE,("IeeeTerminate1284Mode: Phase_Terminate\n"));
Extension->CurrentPhase = PHASE_TERMINATE;
Extension->Connected = FALSE;
Extension->IsIeeeTerminateOk = FALSE;
ParDump2(PAREXIT,("IeeeTerminate1284Mode: End dcr %x\n", dcr));
return;
}
NTSTATUS
IeeeEnter1284Mode(
IN PDEVICE_EXTENSION Extension,
IN UCHAR Extensibility
)
/*++
Routine Description:
This routine performs 1284 negotiation with the peripheral to the
nibble mode protocol.
Arguments:
Controller - Supplies the port address.
DeviceIdRequest - Supplies whether or not this is a request for a device
id.
Return Value:
STATUS_SUCCESS - Successful negotiation.
otherwise - Unsuccessful negotiation.
--*/
{
PUCHAR wPortDCR;
PUCHAR Controller;
UCHAR dcr;
// BOOLEAN xFlag;
NTSTATUS Status = STATUS_SUCCESS;
const USHORT sPeriphResponseTime = 35;
Controller = Extension->Controller;
wPortDCR = Controller + OFFSET_DCR;
ParDump2(PARENTRY,("IeeeEnter1284Mode: Start Controller %x\n", Controller));
/* =============== Host Prep for Pre State 0 ===============8
Set the following just in case someone didn't
put the port in compatibility mode before we got it.
DIR = Don't Care
IRQEN = Don't Care
1284/SelectIn = Low
nReverseReq/ (ECP only)= High for ECP / Don't Care for Nibble
I will do ahead and set it to high
since Nibble doesn't care.
HostAck/HostBusy = High
HostClk/nStrobe = Don't Care
============================================================ */
dcr = READ_PORT_UCHAR(wPortDCR); // Get content of DCR.
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, INACTIVE, ACTIVE, ACTIVE, DONT_CARE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
KeStallExecutionProcessor(2);
/* =============== Host Pre State 0 Negotiation ===============8
DIR = Low ( Don't Care by spec )
IRQEN = Low ( Don't Care by spec )
1284/SelectIn = Low
nReverseReq/ (ECP only)= High ( Don't Care by spec )
HostAck/HostBusy = High
HostClk/nStrobe = High
============================================================ */
dcr = UPDATE_DCR(dcr, INACTIVE, INACTIVE, INACTIVE, ACTIVE, ACTIVE, ACTIVE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
KeStallExecutionProcessor(2);
/* =============== Host State 0 Negotiation ===============8
Place the extensibility request value on the data bus - state 0.
============================================================ */
Extension->CurrentEvent = 0;
WRITE_PORT_UCHAR(Controller + DATA_OFFSET, Extensibility);
KeStallExecutionProcessor(2);
/* =========== Host State 1 Negotiation Phase ===========8
DIR = Don't Care
IRQEN = Don't Care
1284/SelectIn = High (Signals State 1)
nReverseReq/ (ECP only)= Don't Care
HostAck/HostBusy = Low (Signals state 1)
HostClk/nStrobe = High
============================================================ */
Extension->CurrentEvent = 1;
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, ACTIVE, DONT_CARE, INACTIVE, ACTIVE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
/* =============== Periph State 2 Negotiation ===============8
PeriphAck/PtrBusy = Don't Care
PeriphClk/PtrClk = low Signals State 2
nAckReverse/AckDataReq = high Signals State 2
XFlag = high Signals State 2
**Note: It is high at state 2
for both ecp and nibble
nPeriphReq/nDataAvail = high Signals State 2
============================================================ */
Extension->CurrentEvent = 2;
if (!CHECK_DSR(Controller, DONT_CARE, INACTIVE, ACTIVE, ACTIVE, ACTIVE,
sPeriphResponseTime)) {
KeStallExecutionProcessor(2);
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, INACTIVE, DONT_CARE, ACTIVE, DONT_CARE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
ParDump2(PARIEEE, ("IeeeEnter1284Mode: %x - Extensibility=%x, FAIL - TIMEOUT on Event 2\n",
Extension->Controller, Extensibility) );
Extension->CurrentPhase = PHASE_UNKNOWN;
Extension->Connected = FALSE;
Extension->IsIeeeTerminateOk = FALSE;
return STATUS_INVALID_DEVICE_REQUEST;
}
/* =============== Host State 3 Negotiation ===============8
DIR = Don't Care
IRQEN = Don't Care
1284/SelectIn = High
nReverseReq/ (ECP only)= Don't Care
HostAck/HostBusy = Low
HostClk/nStrobe = Low (signals State 3)
NOTE: Strobe the Extensibility byte
============================================================ */
Extension->CurrentEvent = 3;
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, ACTIVE, DONT_CARE, INACTIVE, INACTIVE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
// HostClk must be help low for at least .5 microseconds.
//
KeStallExecutionProcessor(2);
/* =============== Host State 4 Negotiation ===============8
DIR = Don't Care
IRQEN = Don't Care
1284/SelectIn = High
nReverseReq/ (ECP only)= Don't Care
HostAck/HostBusy = High (signals State 4)
HostClk/nStrobe = High (signals State 4)
NOTE: nReverseReq should be high in ECP, but this line is only
valid for ECP. Since it isn't used for signaling
anything in negotiation, let's just ignore it for now.
============================================================ */
Extension->CurrentEvent = 4;
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, ACTIVE, DONT_CARE, ACTIVE, ACTIVE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
/* ============== Periph State 5/6 Negotiation ===============
PeriphAck/PtrBusy = Don't Care. low (ECP) / Don't Care (Nibble)
Since this line differs based on Protocol
Let's not check the line.
PeriphClk/PtrClk = high (Signals State 6)
nAckReverse/AckDataReq = Don't Care. low (ECP) / high (Nibble)
Since this line differs based on Protocol
Let's not check the line.
XFlag = Don't Care. high (ECP) / low (Nibble)
Since this line differs based on Protocol
Let's not check the line.
nPeriphReq/nDataAvail = Don't Care. high (ECP) / low (Nibble)
Since this line differs based on Protocol
Let's not check the line.
============== Periph State 5/6 Negotiation ==============8
NOTES:
- It's ok to lump states 5 and 6 together. In state 5 Nibble,
the periph will set XFlag low and nPeriphReq/nDataAvail low.
The periph will then hold for .5ms then set PeriphClk/PtrClk
high. In ECP, state 5 is nAckReverse/AckDataReq going low and
PeriphAck/PtrBusy going low. Followed by a .5ms pause.
Followed by PeriphClk/PtrClk going high.
============================================================ */
Extension->CurrentEvent = 5;
if (!CHECK_DSR(Controller, DONT_CARE, ACTIVE, DONT_CARE, DONT_CARE, DONT_CARE,
sPeriphResponseTime)) {
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, INACTIVE, DONT_CARE, DONT_CARE, DONT_CARE);
WRITE_PORT_UCHAR(wPortDCR, dcr);
ParDump2(PARIEEE, ("IeeeEnter1284Mode: %x - Extensibility=%x, FAIL - TIMEOUT on Events 5/6\n",
Extension->Controller, Extensibility) );
Extension->CurrentPhase = PHASE_UNKNOWN;
Extension->Connected = FALSE;
Extension->IsIeeeTerminateOk = FALSE;
return STATUS_INVALID_DEVICE_REQUEST;
}
KeStallExecutionProcessor(2);
ParDump2(PARENTRY,("IeeeEnter1284Mode: Phase Negotiated Controller %x\n", Controller));
Extension->CurrentPhase = PHASE_NEGOTIATION;
Extension->Connected = TRUE;
return STATUS_SUCCESS;
}
VOID
IeeeDetermineSupportedProtocols(
IN PDEVICE_EXTENSION Extension
)
/*++
Routine Description:
This routine walks the list of all ieee1284 modes, and
flags each of the ones the peripheral supports in
Extension->ProtocolModesSupported. This proc is called from
external IOCTL.
Arguments:
Extension - The parallel device extension
Return Value:
--*/
{
REVERSE_MODE rm;
FORWARD_MODE fm;
// Take CENTRONICS as a given since it is not a
// mode we can neogitate to.
//
// n.b.
// Let's go ahead and mark IEEE_COMPATIBILITY since we
// cannot negotiate into it. But if the someone sets
// IEEE_COMPATIBILITY and the peripheral does not support
// IEEE 1284 compliant compatibility mode then we're gonna
// create one very unhappy peripheral. -- dvrh
Extension->ProtocolModesSupported = CENTRONICS | IEEE_COMPATIBILITY;
//
// Unlikely that we would be connected, but...
//
ParTerminate(Extension);
for (fm = FORWARD_FASTEST; fm < FORWARD_NONE; fm++) {
if (afpForward[fm].fnIsModeSupported)
afpForward[fm].fnIsModeSupported(Extension);
}
for (rm = REVERSE_FASTEST; rm < REVERSE_NONE; rm++) {
if (arpReverse[rm].fnIsModeSupported)
arpReverse[rm].fnIsModeSupported(Extension);
}
return;
}
NTSTATUS
IeeeNegotiateBestMode(
IN PDEVICE_EXTENSION Extension,
IN USHORT usReadMask,
IN USHORT usWriteMask
)
/*++
Routine Description:
This routine walks the list of supported modes, looking for the best
(fastest) mode. It will skip any mode(s) mask passed in.
Arguments:
Extension - The parallel device extension
Return Value:
STATUS_SUCCESS - Successful negotiation.
otherwise - Unsuccessful negotiation.
--*/
{
REVERSE_MODE rm;
FORWARD_MODE fm;
//
// A USHORT is provided in the extension so that each of the protocols
// can decide whether they need to negotiate each time we go through this
// process...
//
//
// Unlikely that we would be connected, but...
//
ParDump2(PARENTRY, ("IeeeNegotiateBestMode: Enter. Skipping Fwd [%lx] Rev [%lx]\n",
usWriteMask, usReadMask));
ParTerminate(Extension);
Extension->IdxForwardProtocol = FORWARD_NONE;
Extension->IdxReverseProtocol = REVERSE_NONE;
for (fm = FORWARD_FASTEST; fm < FORWARD_NONE; fm++) {
if (!(afpForward[fm].Protocol & usWriteMask)) {
if (afpForward[fm].fnIsModeSupported) {
ParDump2( PARINFO, ("IeeeNegotiateBestMode: Calling ForwardIsSupportedRoutine.\n"));
if (afpForward[fm].fnIsModeSupported(Extension)) {
Extension->IdxForwardProtocol = (USHORT)fm;
break;
}
}
}
}
for (rm = REVERSE_FASTEST; rm < REVERSE_NONE; rm++) {
if (!(arpReverse[rm].Protocol & usReadMask)) {
if (arpReverse[rm].fnIsModeSupported) {
ParDump2( PARINFO, ("IeeeNegotiateBestMode: Calling ReverseIsSupportedRoutine.\n"));
if (arpReverse[rm].fnIsModeSupported(Extension)) {
Extension->IdxReverseProtocol = (USHORT)rm;
break;
}
}
}
}
#if (1 == DVRH_USE_CORRECT_PTRS)
Extension->fnRead = arpReverse[Extension->IdxReverseProtocol].fnRead;
Extension->fnWrite = afpForward[Extension->IdxForwardProtocol].fnWrite;
#endif
ParDump2( PAREXIT, ("IeeeNegotiateBestMode: Exit. Fwd [%x] Rev [%x]\n", fm, rm));
return STATUS_SUCCESS;
}
NTSTATUS
IeeeNegotiateMode(
IN PDEVICE_EXTENSION Extension,
IN USHORT usReadMask,
IN USHORT usWriteMask
)
/*++
Routine Description:
This routine walks the list of supported modes, looking for the best
(fastest) mode which is also in the mode mask passed in.
Arguments:
Extension - The parallel device extension
Return Value:
STATUS_SUCCESS - Successful negotiation.
otherwise - Unsuccessful negotiation.
--*/
{
REVERSE_MODE rm;
FORWARD_MODE fm;
//
// A USHORT is provided in the extension so that each of the protocols
// can decide whether they need to negotiate each time we go through this
// process...
//
//
// Unlikely that we would be connected, but...
//
ParDump2(PARENTRY, ("IeeeNegotiateMode: Enter\n"));
ParTerminate(Extension);
Extension->IdxForwardProtocol = FORWARD_NONE;
Extension->IdxReverseProtocol = REVERSE_NONE;
for (fm = FORWARD_FASTEST; fm < FORWARD_NONE; fm++) {
if (afpForward[fm].Protocol & usWriteMask) {
if (afpForward[fm].fnIsModeSupported) {
ParDump2( PARINFO, ("IeeeNegotiateMode: Calling ForwardIsSupportedRoutine.\n"));
if (afpForward[fm].fnIsModeSupported(Extension)) {
Extension->IdxForwardProtocol = (USHORT)fm;
break;
}
} else {
ParDump2( PARINFO, ("IeeeNegotiateMode: No ForwardIsSupportedRoutine.\n"));
Extension->IdxForwardProtocol = (USHORT)fm;
break;
}
}
}
ParDump2( PARINFO, ("IeeeNegotiateMode: Extension->IdxForwardProtocol = %x.\n", fm));
for (rm = REVERSE_FASTEST; rm < REVERSE_NONE; rm++) {
if (arpReverse[rm].Protocol & usReadMask) {
if (arpReverse[rm].fnIsModeSupported) {
ParDump2( PARINFO, ("IeeeNegotiateMode: Calling ReverseIsSupportedRoutine.\n"));
if (arpReverse[rm].fnIsModeSupported(Extension)) {
Extension->IdxReverseProtocol = (USHORT)rm;
break;
}
} else {
ParDump2( PARINFO, ("IeeeNegotiateMode: No ReverseIsSupportedRoutine.\n"));
Extension->IdxReverseProtocol = (USHORT)rm;
break;
}
}
}
ParDump2( PARINFO, ("IeeeNegotiateMode: Extension->IdxReverseProtocol = %x.\n", rm));
#if (1 == DVRH_USE_CORRECT_PTRS)
Extension->fnRead = arpReverse[Extension->IdxReverseProtocol].fnRead;
Extension->fnWrite = afpForward[Extension->IdxForwardProtocol].fnWrite;
#endif
ParDump2( PAREXIT, ("IeeeNegotiateMode: Exit\n"));
return STATUS_SUCCESS;
}