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.
667 lines
22 KiB
667 lines
22 KiB
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1993 - 1999
|
|
|
|
Module Name:
|
|
|
|
nibble.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the code to do nibble mode reads.
|
|
|
|
Author:
|
|
|
|
Anthony V. Ercolano 1-Aug-1992
|
|
Norbert P. Kusters 22-Oct-1993
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
Revision History :
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
|
|
BOOLEAN
|
|
ParIsNibbleSupported(
|
|
IN PDEVICE_EXTENSION Extension
|
|
);
|
|
|
|
BOOLEAN
|
|
ParIsChannelizedNibbleSupported(
|
|
IN PDEVICE_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterNibbleMode(
|
|
IN PDEVICE_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
NTSTATUS
|
|
ParEnterChannelizedNibbleMode(
|
|
IN PDEVICE_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
);
|
|
|
|
VOID
|
|
ParTerminateNibbleMode(
|
|
IN PDEVICE_EXTENSION Extension
|
|
);
|
|
|
|
NTSTATUS
|
|
ParNibbleModeRead(
|
|
IN PDEVICE_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
);
|
|
|
|
|
|
BOOLEAN
|
|
ParIsNibbleSupported(
|
|
IN PDEVICE_EXTENSION Extension
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine determines whether or not nibble mode is suported
|
|
by trying to negotiate when asked.
|
|
|
|
Arguments:
|
|
|
|
Extension - The device extension.
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
NTSTATUS Status;
|
|
|
|
ParDump2(PARINFO, ("ParIsNibbleSupported: Start\n"));
|
|
|
|
if (Extension->BadProtocolModes & NIBBLE) {
|
|
ParDump2(PARINFO, ("ParIsNibbleSupported: BAD PROTOCOL Leaving\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (Extension->ProtocolModesSupported & NIBBLE) {
|
|
ParDump2(PARINFO, ("ParIsNibbleSupported: Already Checked YES Leaving\n"));
|
|
return TRUE;
|
|
}
|
|
|
|
Status = ParEnterNibbleMode (Extension, FALSE);
|
|
ParTerminateNibbleMode (Extension);
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
ParDump2(PARINFO, ("ParIsNibbleSupported: SUCCESS Leaving\n"));
|
|
Extension->ProtocolModesSupported |= NIBBLE;
|
|
return TRUE;
|
|
}
|
|
|
|
ParDump2(PARINFO, ("ParIsNibbleSupported: UNSUCCESSFUL Leaving\n"));
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
ParIsChannelizedNibbleSupported(
|
|
IN PDEVICE_EXTENSION Extension
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine determines whether or not channelized nibble mode is suported (1284.3)
|
|
by trying to negotiate when asked.
|
|
|
|
Arguments:
|
|
|
|
Extension - The device extension.
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
NTSTATUS Status;
|
|
|
|
ParDump2(PARINFO, ("ParIsChannelizedNibbleSupported: Start\n"));
|
|
|
|
if (Extension->BadProtocolModes & CHANNEL_NIBBLE) {
|
|
ParDump2(PARINFO, ("ParIsChannelizedNibbleSupported: BAD PROTOCOL Leaving\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (Extension->ProtocolModesSupported & CHANNEL_NIBBLE) {
|
|
ParDump2(PARINFO, ("ParIsChannelizedNibbleSupported: Already Checked YES Leaving\n"));
|
|
return TRUE;
|
|
}
|
|
|
|
Status = ParEnterChannelizedNibbleMode (Extension, FALSE);
|
|
ParTerminateNibbleMode (Extension);
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
ParDump2(PARINFO, ("ParIsChannelizedNibbleSupported: SUCCESS Leaving\n"));
|
|
Extension->ProtocolModesSupported |= CHANNEL_NIBBLE;
|
|
return TRUE;
|
|
}
|
|
|
|
ParDump2(PARINFO, ("ParIsChannelizedNibbleSupported: UNSUCCESSFUL Leaving\n"));
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
ParEnterNibbleMode(
|
|
IN PDEVICE_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
)
|
|
|
|
/*++
|
|
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
ParDump2(PARINFO, ("ParEnterNibbleMode: Start\n"));
|
|
|
|
if ( Extension->ModeSafety == SAFE_MODE ) {
|
|
if (DeviceIdRequest) {
|
|
Status = IeeeEnter1284Mode (Extension, NIBBLE_EXTENSIBILITY | DEVICE_ID_REQ);
|
|
} else {
|
|
Status = IeeeEnter1284Mode (Extension, NIBBLE_EXTENSIBILITY);
|
|
}
|
|
} else {
|
|
ParDump2(PARINFO, ("ParEnterNibbleMode: In UNSAFE_MODE.\n"));
|
|
Extension->Connected = TRUE;
|
|
}
|
|
|
|
// dvdr
|
|
if (NT_SUCCESS(Status)) {
|
|
ParDump2(PARINFO, ("ParEnterNibbleMode: IeeeEnter1284Mode returned success\n"));
|
|
Extension->CurrentEvent = 6;
|
|
Extension->CurrentPhase = PHASE_NEGOTIATION;
|
|
Extension->IsIeeeTerminateOk = TRUE;
|
|
} else {
|
|
ParDump2(PARINFO, ("ParEnterNibbleMode: IeeeEnter1284Mode returned unsuccessful\n"));
|
|
ParTerminateNibbleMode ( Extension );
|
|
Extension->CurrentPhase = PHASE_UNKNOWN;
|
|
Extension->IsIeeeTerminateOk = FALSE;
|
|
}
|
|
|
|
ParDump2(PARINFO, ("ParEnterNibbleMode: Leaving with Status : %x \n", Status));
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
ParEnterChannelizedNibbleMode(
|
|
IN PDEVICE_EXTENSION Extension,
|
|
IN BOOLEAN DeviceIdRequest
|
|
)
|
|
|
|
/*++
|
|
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
ParDump2(PARINFO, ("ParEnterChannelizedNibbleMode: Start\n"));
|
|
|
|
if ( Extension->ModeSafety == SAFE_MODE ) {
|
|
if (DeviceIdRequest) {
|
|
Status = IeeeEnter1284Mode (Extension, CHANNELIZED_EXTENSIBILITY | DEVICE_ID_REQ);
|
|
} else {
|
|
Status = IeeeEnter1284Mode (Extension, CHANNELIZED_EXTENSIBILITY);
|
|
}
|
|
} else {
|
|
ParDump2(PARINFO, ("ParEnterChannelizedNibbleMode: In UNSAFE_MODE.\n"));
|
|
Extension->Connected = TRUE;
|
|
}
|
|
|
|
// dvdr
|
|
if (NT_SUCCESS(Status)) {
|
|
ParDump2(PARINFO, ("ParEnterChannelizedNibbleMode: IeeeEnter1284Mode returned success\n"));
|
|
Extension->CurrentEvent = 6;
|
|
Extension->CurrentPhase = PHASE_NEGOTIATION;
|
|
Extension->IsIeeeTerminateOk = TRUE;
|
|
} else {
|
|
ParDump2(PARINFO, ("ParEnterChannelizedNibbleMode: IeeeEnter1284Mode returned unsuccessful\n"));
|
|
ParTerminateNibbleMode ( Extension );
|
|
Extension->CurrentPhase = PHASE_UNKNOWN;
|
|
Extension->IsIeeeTerminateOk = FALSE;
|
|
}
|
|
|
|
ParDump2(PARINFO, ("ParEnterChannelizedNibbleMode: Leaving with Status : %x \n", Status));
|
|
return Status;
|
|
}
|
|
|
|
VOID
|
|
ParTerminateNibbleMode(
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
ParDump2(PARINFO, ("ParTerminateNibbleMode: Enter.\n"));
|
|
if ( Extension->ModeSafety == SAFE_MODE ) {
|
|
IeeeTerminate1284Mode (Extension);
|
|
} else {
|
|
ParDump2(PARINFO, ("ParTerminateNibbleMode: In UNSAFE_MODE.\n"));
|
|
Extension->Connected = FALSE;
|
|
}
|
|
ParDump2(PARINFO, ("ParTerminateNibbleMode: Exit.\n"));
|
|
}
|
|
|
|
NTSTATUS
|
|
ParNibbleModeRead(
|
|
IN PDEVICE_EXTENSION Extension,
|
|
IN PVOID Buffer,
|
|
IN ULONG BufferSize,
|
|
OUT PULONG BytesTransferred
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine performs a 1284 nibble mode read into the given
|
|
buffer for no more than 'BufferSize' bytes.
|
|
|
|
Arguments:
|
|
|
|
Extension - Supplies the device extension.
|
|
|
|
Buffer - Supplies the buffer to read into.
|
|
|
|
BufferSize - Supplies the number of bytes in the buffer.
|
|
|
|
BytesTransferred - Returns the number of bytes transferred.
|
|
|
|
--*/
|
|
|
|
{
|
|
PUCHAR Controller;
|
|
PUCHAR wPortDCR;
|
|
PUCHAR wPortDSR;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PUCHAR p = (PUCHAR)Buffer;
|
|
UCHAR dsr, dcr;
|
|
UCHAR nibble[2];
|
|
ULONG i, j;
|
|
|
|
Controller = Extension->Controller;
|
|
wPortDCR = Controller + OFFSET_DCR;
|
|
wPortDSR = Controller + OFFSET_DSR;
|
|
|
|
// Read nibbles according to 1284 spec.
|
|
ParDump2(PARENTRY,("ParNibbleModeRead: Start\n"));
|
|
|
|
dcr = READ_PORT_UCHAR(wPortDCR);
|
|
|
|
switch (Extension->CurrentPhase) {
|
|
|
|
case PHASE_NEGOTIATION:
|
|
|
|
ParDump2(PARINFO,("ParNibbleModeRead: PHASE_NEGOTIATION\n"));
|
|
|
|
// Starting in state 6 - where do we go from here?
|
|
// To Reverse Idle or Reverse Data Transfer Phase depending if
|
|
// data is available.
|
|
|
|
dsr = READ_PORT_UCHAR(wPortDSR);
|
|
|
|
// =============== Periph State 6 ===============8
|
|
// PeriphAck/PtrBusy = Don't Care
|
|
// PeriphClk/PtrClk = Don't Care (should be high
|
|
// and the nego. proc already
|
|
// checked this)
|
|
// nAckReverse/AckDataReq = Don't Care (should be high)
|
|
// XFlag = Don't Care (should be low)
|
|
// nPeriphReq/nDataAvail = High/Low (line status determines
|
|
// which state we move to)
|
|
Extension->CurrentEvent = 6;
|
|
#if (0 == DVRH_USE_NIBBLE_MACROS)
|
|
if (dsr & DSR_NOT_DATA_AVAIL)
|
|
#else
|
|
if (TEST_DSR(dsr, DONT_CARE, DONT_CARE, DONT_CARE, DONT_CARE, ACTIVE ))
|
|
#endif
|
|
{
|
|
// Data is NOT available - go to Reverse Idle
|
|
ParDump2(PARINFO,("ParNibbleModeRead: PHASE_REVERSE_IDLE\n"));
|
|
// Host enters state 7 - officially in Reverse Idle now
|
|
|
|
// Must stall for at least .5 microseconds before this state.
|
|
KeStallExecutionProcessor(1);
|
|
|
|
/* =============== Host State 7 Nibble Reverse Idle ===============8
|
|
DIR = Don't Care
|
|
IRQEN = Don't Care
|
|
1284/SelectIn = High
|
|
nReverseReq/ (ECP only)= Don't Care
|
|
HostAck/HostBusy = Low (signals State 7)
|
|
HostClk/nStrobe = High
|
|
============================================================ */
|
|
Extension->CurrentEvent = 7;
|
|
#if (0 == DVRH_USE_NIBBLE_MACROS)
|
|
dcr |= DCR_NOT_HOST_BUSY;
|
|
#else
|
|
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, ACTIVE, DONT_CARE, INACTIVE, ACTIVE);
|
|
#endif
|
|
WRITE_PORT_UCHAR(wPortDCR, dcr);
|
|
|
|
Extension->CurrentPhase = PHASE_REVERSE_IDLE ;
|
|
// FALL THRU TO reverse idle
|
|
} else {
|
|
|
|
// Data is available, go to Reverse Transfer Phase
|
|
Extension->CurrentPhase = PHASE_REVERSE_XFER ;
|
|
// DO NOT fall thru
|
|
goto PhaseReverseXfer; // please save me from my sins!
|
|
}
|
|
|
|
|
|
case PHASE_REVERSE_IDLE:
|
|
|
|
// Check to see if the peripheral has indicated Interrupt Phase and if so,
|
|
// get us ready to reverse transfer.
|
|
|
|
// See if data is available (looking for state 19)
|
|
dsr = READ_PORT_UCHAR(Controller + OFFSET_DSR);
|
|
|
|
if (!(dsr & DSR_NOT_DATA_AVAIL)) {
|
|
|
|
dcr = READ_PORT_UCHAR(wPortDCR);
|
|
// =========== Host State 20 Interrupt Phase ===========8
|
|
// DIR = Don't Care
|
|
// IRQEN = Don't Care
|
|
// 1284/SelectIn = High
|
|
// nReverseReq/ (ECP only) = Don't Care
|
|
// HostAck/HostBusy = High (Signals state 20)
|
|
// HostClk/nStrobe = High
|
|
//
|
|
// Data is available, get us to Reverse Transfer Phase
|
|
Extension->CurrentEvent = 20;
|
|
dcr = UPDATE_DCR(dcr, DONT_CARE, DONT_CARE, ACTIVE, DONT_CARE, ACTIVE, ACTIVE);
|
|
WRITE_PORT_UCHAR(wPortDCR, dcr);
|
|
|
|
// =============== Periph State 21 HBDA ===============8
|
|
// PeriphAck/PtrBusy = Don't Care
|
|
// PeriphClk/PtrClk = Don't Care (should be high)
|
|
// nAckReverse/AckDataReq = low (signals state 21)
|
|
// XFlag = Don't Care (should be low)
|
|
// nPeriphReq/nDataAvail = Don't Care (should be low)
|
|
Extension->CurrentEvent = 21;
|
|
if (CHECK_DSR(Controller,
|
|
DONT_CARE, DONT_CARE, INACTIVE,
|
|
DONT_CARE, DONT_CARE,
|
|
IEEE_MAXTIME_TL)) {
|
|
|
|
// Got state 21
|
|
// Let's jump to Reverse Xfer and get the data
|
|
Extension->CurrentPhase = PHASE_REVERSE_XFER;
|
|
goto PhaseReverseXfer;
|
|
|
|
} else {
|
|
|
|
// Timeout on state 21
|
|
Extension->IsIeeeTerminateOk = TRUE;
|
|
Status = STATUS_IO_DEVICE_ERROR;
|
|
Extension->CurrentPhase = PHASE_UNKNOWN;
|
|
ParDump2(PARERRORS, ("ParNibbleModeRead:Failed State 21: Controller %x dcr %x\n",
|
|
Controller, dcr));
|
|
// NOTE: Don't ASSERT Here. An Assert here can bite you if you are in
|
|
// Nibble Rev and you device is off/offline.
|
|
// dvrh 2/25/97
|
|
goto NibbleReadExit;
|
|
}
|
|
|
|
} else {
|
|
|
|
// Data is NOT available - do nothing
|
|
// The device doesn't report any data, it still looks like it is
|
|
// in ReverseIdle. Just to make sure it hasn't powered off or somehow
|
|
// jumped out of Nibble mode, test also for AckDataReq high and XFlag low
|
|
// and nDataAvaul high.
|
|
Extension->CurrentEvent = 18;
|
|
dsr = READ_PORT_UCHAR(Controller + OFFSET_DSR);
|
|
if(( dsr & DSR_NIBBLE_VALIDATION )== DSR_NIBBLE_TEST_RESULT ) {
|
|
|
|
Extension->CurrentPhase = PHASE_REVERSE_IDLE ;
|
|
|
|
} else {
|
|
#if DVRH_BUS_RESET_ON_ERROR
|
|
BusReset(wPortDCR); // Pass in the dcr address
|
|
#endif
|
|
// Appears we failed state 19.
|
|
Extension->IsIeeeTerminateOk = TRUE;
|
|
Status = STATUS_IO_DEVICE_ERROR;
|
|
Extension->CurrentPhase = PHASE_UNKNOWN;
|
|
ParDump2(PARERRORS, ("ParNibbleModeRead:Failed State 19: Controller %x dcr %x\n",
|
|
Controller, dcr));
|
|
}
|
|
goto NibbleReadExit;
|
|
|
|
}
|
|
|
|
PhaseReverseXfer:
|
|
|
|
case PHASE_REVERSE_XFER:
|
|
|
|
ParDump2(PARINFO,("ParNibbleModeRead:PHASE_REVERSE_IDLE\n"));
|
|
|
|
for (i = 0; i < BufferSize; i++) {
|
|
|
|
for (j = 0; j < 2; j++) {
|
|
|
|
// Host enters state 7 or 12 depending if nibble 1 or 2
|
|
// StoreControl (Controller, HDReady);
|
|
dcr |= DCR_NOT_HOST_BUSY;
|
|
WRITE_PORT_UCHAR(wPortDCR, dcr);
|
|
|
|
// =============== Periph State 9 ===============8
|
|
// PeriphAck/PtrBusy = Don't Care (Bit 3 of Nibble)
|
|
// PeriphClk/PtrClk = low (signals state 9)
|
|
// nAckReverse/AckDataReq = Don't Care (Bit 2 of Nibble)
|
|
// XFlag = Don't Care (Bit 1 of Nibble)
|
|
// nPeriphReq/nDataAvail = Don't Care (Bit 0 of Nibble)
|
|
Extension->CurrentEvent = 9;
|
|
if (!CHECK_DSR(Controller,
|
|
DONT_CARE, INACTIVE, DONT_CARE,
|
|
DONT_CARE, DONT_CARE,
|
|
IEEE_MAXTIME_TL)) {
|
|
// Time out.
|
|
// Bad things happened - timed out on this state,
|
|
// Mark Status as bad and let our mgr kill current mode.
|
|
|
|
Extension->IsIeeeTerminateOk = FALSE;
|
|
Status = STATUS_IO_DEVICE_ERROR;
|
|
ParDump2(PARERRORS, ("ParNibbleModeRead:Failed State 9: Controller %x dcr %x\n",
|
|
Controller, dcr));
|
|
Extension->CurrentPhase = PHASE_UNKNOWN;
|
|
goto NibbleReadExit;
|
|
}
|
|
|
|
// Read Nibble
|
|
nibble[j] = READ_PORT_UCHAR(wPortDSR);
|
|
|
|
/* ============== Host State 10 Nibble Read ===============8
|
|
DIR = Don't Care
|
|
IRQEN = Don't Care
|
|
1284/SelectIn = High
|
|
HostAck/HostBusy = High (signals State 10)
|
|
HostClk/nStrobe = High
|
|
============================================================ */
|
|
Extension->CurrentEvent = 10;
|
|
dcr &= ~DCR_NOT_HOST_BUSY;
|
|
WRITE_PORT_UCHAR(wPortDCR, dcr);
|
|
|
|
// =============== Periph State 11 ===============8
|
|
// PeriphAck/PtrBusy = Don't Care (Bit 3 of Nibble)
|
|
// PeriphClk/PtrClk = High (signals state 11)
|
|
// nAckReverse/AckDataReq = Don't Care (Bit 2 of Nibble)
|
|
// XFlag = Don't Care (Bit 1 of Nibble)
|
|
// nPeriphReq/nDataAvail = Don't Care (Bit 0 of Nibble)
|
|
Extension->CurrentEvent = 11;
|
|
if (!CHECK_DSR(Controller,
|
|
DONT_CARE, ACTIVE, DONT_CARE,
|
|
DONT_CARE, DONT_CARE,
|
|
IEEE_MAXTIME_TL)) {
|
|
// Time out.
|
|
// Bad things happened - timed out on this state,
|
|
// Mark Status as bad and let our mgr kill current mode.
|
|
Status = STATUS_IO_DEVICE_ERROR;
|
|
Extension->IsIeeeTerminateOk = FALSE;
|
|
ParDump2(PARERRORS, ("ParNibbleModeRead:Failed State 11: Controller %x dcr %x\n",
|
|
Controller, dcr));
|
|
Extension->CurrentPhase = PHASE_UNKNOWN;
|
|
goto NibbleReadExit;
|
|
}
|
|
}
|
|
|
|
// Read two nibbles - make them into one byte.
|
|
|
|
p[i] = (((nibble[0]&0x38)>>3)&0x07) |
|
|
((nibble[0]&0x80) ? 0x00 : 0x08);
|
|
p[i] |= (((nibble[1]&0x38)<<1)&0x70) |
|
|
((nibble[1]&0x80) ? 0x00 : 0x80);
|
|
|
|
ParDump2(PARINFO,("ParNibbleModeRead:%x:%c\n", p[i], p[i]));
|
|
|
|
// At this point, we've either received the number of bytes we
|
|
// were looking for, or the peripheral has no more data to
|
|
// send, or there was an error of some sort (of course, in the
|
|
// error case we shouldn't get to this comment). Set the
|
|
// phase to indicate reverse idle if no data available or
|
|
// reverse data transfer if there's some waiting for us
|
|
// to get next time.
|
|
|
|
dsr = READ_PORT_UCHAR(wPortDSR);
|
|
|
|
if (dsr & DSR_NOT_DATA_AVAIL) {
|
|
|
|
// Data is NOT available - go to Reverse Idle
|
|
// Really we are going to HBDNA, but if we set
|
|
// current phase to reverse idle, the next time
|
|
// we get into this function all we have to do
|
|
// is set hostbusy low to indicate idle and
|
|
// we have infinite time to do that.
|
|
// Break out of the loop so we don't try to read
|
|
// data that isn't there.
|
|
// NOTE - this is a successful case even if we
|
|
// didn't read all that the caller requested
|
|
Extension->CurrentPhase = PHASE_REVERSE_IDLE ;
|
|
i++; // account for this last byte transferred
|
|
break;
|
|
|
|
} else {
|
|
// Data is available, go to (remain in ) Reverse Transfer Phase
|
|
Extension->CurrentPhase = PHASE_REVERSE_XFER ;
|
|
}
|
|
} // end for i loop
|
|
|
|
*BytesTransferred = i;
|
|
// DON'T FALL THRU THIS ONE
|
|
break;
|
|
|
|
default:
|
|
// I'm gonna mark this as false. There is not a correct answer here.
|
|
// The peripheral and the host are out of sync. I'm gonna reset myself
|
|
// and the peripheral.
|
|
Extension->IsIeeeTerminateOk = FALSE;
|
|
Status = STATUS_IO_DEVICE_ERROR;
|
|
Extension->CurrentPhase = PHASE_UNKNOWN ;
|
|
|
|
ParDump2(PARERRORS, ("ParNibbleModeRead:Failed State 9: Unknown Phase. Controller %x dcr %x\n",
|
|
Controller, dcr));
|
|
ParDump2(PARERRORS, ( "ParNibbleModeRead: You're hosed man.\n" ));
|
|
ParDump2(PARERRORS, ( "ParNibbleModeRead: If you are here, you've got a bug somewhere else.\n" ));
|
|
ParDump2(PARERRORS, ( "ParNibbleModeRead: Go fix it!\n" ));
|
|
goto NibbleReadExit;
|
|
break;
|
|
} // end switch
|
|
|
|
NibbleReadExit:
|
|
|
|
ParDump2(PARINFO,("ParNibbleModeRead:PHASE_REVERSE_IDLE\n"));
|
|
|
|
if( Extension->CurrentPhase == PHASE_REVERSE_IDLE ) {
|
|
// Host enters state 7 - officially in Reverse Idle now
|
|
dcr |= DCR_NOT_HOST_BUSY;
|
|
|
|
WRITE_PORT_UCHAR (wPortDCR, dcr);
|
|
}
|
|
|
|
ParDump2(PAREXIT,("ParNibbleModeRead:End [%d] bytes read = %d\n",
|
|
NT_SUCCESS(Status), *BytesTransferred));
|
|
Extension->log.NibbleReadCount += *BytesTransferred;
|
|
return Status;
|
|
}
|
|
|