id_ata.cpp File Reference

#include "stdafx.h"

Include dependency graph for id_ata.cpp:

Go to the source code of this file.

Macros
#define	RESET_COMPLETE_CURRENT   0x00
#define	RESET_COMPLETE_ALL   0x01
#define	RESET_COMPLETE_NONE   0x02
#define	RETTYPE_XXableInterrupts   VOID
#define	RETVAL_XXableInterrupts
#define	ITEMS_TO_QUERY   2
#define	AtapiWritePortN_template(_type, _Type, sz)
#define	AtapiWritePortExN_template(_type, _Type, sz)
#define	AtapiReadPortN_template(_type, _Type, sz)
#define	AtapiReadPortExN_template(_type, _Type, sz)
#define	AtapiReadPortBufferN_template(_type, _Type, sz)
#define	AtapiWritePortBufferN_template(_type, _Type, sz)
#define	SetCheckPoint(cp)
#define	ITEMS_TO_QUERY   2
#define	DEBUG_MSG_BUFFER_SIZE   512

Functions
BOOLEAN NTAPI	AtapiResetController__ (IN PVOID HwDeviceExtension, IN ULONG PathId, IN UCHAR CompleteType)
VOID NTAPI	AtapiHwInitialize__ (IN PHW_DEVICE_EXTENSION deviceExtension, IN ULONG lChannel)
VOID NTAPI	UniataUserDeviceReset (PHW_DEVICE_EXTENSION deviceExtension, PHW_LU_EXTENSION LunExt, ULONG lChannel)
VOID NTAPI	AtapiCallBack_X (IN PVOID HwDeviceExtension)
RETTYPE_XXableInterrupts NTAPI	AtapiInterruptDpc (IN PVOID HwDeviceExtension)
RETTYPE_XXableInterrupts NTAPI	AtapiEnableInterrupts__ (IN PVOID HwDeviceExtension)
VOID NTAPI	AtapiQueueTimerDpc (IN PVOID HwDeviceExtension, IN ULONG lChannel, IN PHW_TIMER HwScsiTimer, IN ULONG MiniportTimerValue)
SCSI_ADAPTER_CONTROL_STATUS NTAPI	AtapiAdapterControl (IN PVOID HwDeviceExtension, IN SCSI_ADAPTER_CONTROL_TYPE ControlType, IN PVOID Parameters)
BOOLEAN NTAPI	AtapiRegGetStringParameterValue (IN PWSTR RegistryPath, IN PWSTR Name, IN PWCHAR Str, IN ULONG MaxLen)
VOID DDKFASTAPI	UniataNanoSleep (ULONG nano)
	AtapiWritePortN_template (ULONG, Ulong, 4)
	AtapiWritePortN_template (USHORT, Ushort, 2)
	AtapiWritePortN_template (UCHAR, Uchar, 1)
	AtapiWritePortExN_template (ULONG, Ulong, 4)
	AtapiWritePortExN_template (UCHAR, Uchar, 1)
	AtapiReadPortN_template (ULONG, Ulong, 4)
	AtapiReadPortN_template (USHORT, Ushort, 2)
	AtapiReadPortN_template (UCHAR, Uchar, 1)
	AtapiReadPortExN_template (ULONG, Ulong, 4)
	AtapiReadPortExN_template (UCHAR, Uchar, 1)
	AtapiWritePortBufferN_template (ULONG, Ulong, 4)
	AtapiWritePortBufferN_template (USHORT, Ushort, 2)
	AtapiReadPortBufferN_template (ULONG, Ulong, 4)
	AtapiReadPortBufferN_template (USHORT, Ushort, 2)
UCHAR DDKFASTAPI	AtapiSuckPort2 (IN PHW_CHANNEL chan)
ULONG DDKFASTAPI	AtapiSuckPortBuffer2 (IN PHW_CHANNEL chan, IN PUSHORT Buffer, IN ULONG Count)
UCHAR DDKFASTAPI	SelectDrive (IN PHW_CHANNEL chan, IN ULONG DeviceNumber)
UCHAR DDKFASTAPI	WaitOnBusy (IN PHW_CHANNEL chan)
UCHAR DDKFASTAPI	WaitOnBusyLong (IN PHW_CHANNEL chan)
UCHAR DDKFASTAPI	WaitOnBaseBusy (IN PHW_CHANNEL chan)
UCHAR DDKFASTAPI	WaitOnBaseBusyLong (IN PHW_CHANNEL chan)
UCHAR DDKFASTAPI	UniataIsIdle (IN struct _HW_DEVICE_EXTENSION *deviceExtension, IN UCHAR Status)
UCHAR DDKFASTAPI	WaitForIdleLong (IN PHW_CHANNEL chan)
UCHAR DDKFASTAPI	WaitForDrq (IN PHW_CHANNEL chan)
UCHAR DDKFASTAPI	WaitShortForDrq (IN PHW_CHANNEL chan)
VOID DDKFASTAPI	AtapiSoftReset (IN PHW_CHANNEL chan, IN ULONG DeviceNumber)
VOID DDKFASTAPI	AtapiHardReset (IN struct _HW_CHANNEL *chan, IN BOOLEAN DisableInterrupts, IN ULONG Delay)
UCHAR NTAPI	AtaCommand48 (IN PHW_DEVICE_EXTENSION deviceExtension, IN ULONG DeviceNumber, IN ULONG lChannel, IN UCHAR command, IN ULONGLONG lba, IN USHORT count, IN USHORT feature, IN ULONG wait_flags)
UCHAR NTAPI	AtaCommand (IN PHW_DEVICE_EXTENSION deviceExtension, IN ULONG DeviceNumber, IN ULONG lChannel, IN UCHAR command, IN USHORT cylinder, IN UCHAR head, IN UCHAR sector, IN UCHAR count, IN UCHAR feature, IN ULONG wait_flags)
LONG NTAPI	AtaPio2Mode (LONG pio)
LONG NTAPI	AtaPioMode (PIDENTIFY_DATA2 ident)
LONG NTAPI	AtaWmode (PIDENTIFY_DATA2 ident)
LONG NTAPI	AtaUmode (PIDENTIFY_DATA2 ident)
LONG NTAPI	AtaSAmode (PIDENTIFY_DATA2 ident)
VOID NTAPI	AtapiTimerDpc (IN PVOID HwDeviceExtension)
VOID NTAPI	UniataSnapAtaRegs (IN PHW_CHANNEL chan, IN ULONG DeviceNumber, IN OUT PIDEREGS_EX regs)
BOOLEAN NTAPI	IssueIdentify (IN PVOID HwDeviceExtension, IN ULONG DeviceNumber, IN ULONG lChannel, IN UCHAR Command, IN BOOLEAN NoSetup)
BOOLEAN NTAPI	SetDriveParameters (IN PVOID HwDeviceExtension, IN ULONG DeviceNumber, IN ULONG lChannel)
VOID NTAPI	UniataForgetDevice (PHW_LU_EXTENSION LunExt)
BOOLEAN NTAPI	AtapiResetController (IN PVOID HwDeviceExtension, IN ULONG PathId)
ULONG NTAPI	MapError (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb)
BOOLEAN NTAPI	AtapiHwInitialize (IN PVOID HwDeviceExtension)
VOID NTAPI	AtapiHwInitializeChanger (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb, IN PMECHANICAL_STATUS_INFORMATION_HEADER MechanismStatus)
ULONG NTAPI	AtapiParseArgumentString (IN PCCH String, IN PCCH KeyWord)
VOID NTAPI	AtapiCallBack__ (IN PVOID HwDeviceExtension, IN UCHAR lChannel)
BOOLEAN NTAPI	AtapiInterrupt (IN PVOID HwDeviceExtension)
BOOLEAN NTAPI	AtapiInterrupt2 (IN PKINTERRUPT Interrupt, IN PVOID Isr2HwDeviceExtension)
VOID NTAPI	AtapiEnableInterrupts (IN PVOID HwDeviceExtension, IN ULONG c)
VOID NTAPI	AtapiDisableInterrupts (IN PVOID HwDeviceExtension, IN ULONG c)
VOID	UniataExpectChannelInterrupt (IN struct _HW_CHANNEL *chan, IN BOOLEAN Expecting)
BOOLEAN NTAPI	AtapiCheckInterrupt__ (IN PVOID HwDeviceExtension, IN UCHAR c)
BOOLEAN NTAPI	AtapiInterrupt__ (IN PVOID HwDeviceExtension, IN UCHAR c)
ULONG NTAPI	IdeSendSmartCommand (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb, IN ULONG targetId)
ULONGLONG NTAPI	UniAtaCalculateLBARegs (PHW_LU_EXTENSION LunExt, ULONGLONG startingSector, PULONG max_bcount)
ULONGLONG NTAPI	UniAtaCalculateLBARegsBack (PHW_LU_EXTENSION LunExt, ULONGLONG lba)
ULONG NTAPI	IdeReadWrite (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb, IN ULONG CmdAction)
ULONG NTAPI	IdeVerify (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb)
ULONG NTAPI	AtapiSendCommand (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb, IN ULONG CmdAction)
ULONG NTAPI	IdeSendCommand (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb, IN ULONG CmdAction)
VOID NTAPI	IdeMediaStatus (BOOLEAN EnableMSN, IN PVOID HwDeviceExtension, IN ULONG lChannel, IN ULONG DeviceNumber)
ULONG NTAPI	IdeBuildSenseBuffer (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb)
BOOLEAN NTAPI	UniataNeedQueueing (PHW_DEVICE_EXTENSION deviceExtension, PHW_CHANNEL chan, BOOLEAN TopLevel)
BOOLEAN NTAPI	AtapiStartIo (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb)
BOOLEAN NTAPI	AtapiStartIo__ (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb, IN BOOLEAN TopLevel)
ULONG NTAPI	DriverEntry (IN PVOID DriverObject, IN PVOID Argument2)
PSCSI_REQUEST_BLOCK NTAPI	BuildMechanismStatusSrb (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb)
PSCSI_REQUEST_BLOCK NTAPI	BuildRequestSenseSrb (IN PVOID HwDeviceExtension, IN PSCSI_REQUEST_BLOCK Srb)
ULONG NTAPI	AtapiRegCheckDevLunValue (IN PVOID HwDeviceExtension, IN PCWCH NamePrefix, IN ULONG chan, IN ULONG dev, IN PCWSTR Name, IN ULONG Default)
ULONG NTAPI	EncodeVendorStr (OUT PWCHAR Buffer, IN PUCHAR Str, IN ULONG Length)
ULONG NTAPI	AtapiRegCheckDevValue (IN PVOID HwDeviceExtension, IN ULONG chan, IN ULONG dev, IN PCWSTR Name, IN ULONG Default)
ULONG NTAPI	AtapiRegCheckParameterValue (IN PVOID HwDeviceExtension, IN PCWSTR PathSuffix, IN PCWSTR Name, IN ULONG Default)
NTHALAPI VOID NTAPI	HalDisplayString (PUCHAR String)
VOID _cdecl	_PrintNtConsole (PCCH DebugMessage,...)

Variables
static const CHAR	ver_string [] = "\n\nATAPI IDE MiniPort Driver (UniATA) v 0." UNIATA_VER_STR "\n"
static const CHAR	uniata_comm_name [] = UNIATA_COMM_PORT_VENDOR_STR " \n"
UNICODE_STRING	SavedRegPath
WCHAR	SavedRegPathBuffer [256]
ULONG	SkipRaids = 1
ULONG	ForceSimplex = 0
LONGLONG	g_Perf = 0
ULONG	g_PerfDt = 0
ULONG	g_WaitBusyInISR = 1
ULONG	g_opt_WaitBusyResetCount = 10000
ULONG	g_opt_WaitBusyCount = 200
ULONG	g_opt_WaitBusyDelay = 10
ULONG	g_opt_WaitDrqDelay = 10
ULONG	g_opt_WaitBusyLongCount = 2000
ULONG	g_opt_WaitBusyLongDelay = 250
ULONG	g_opt_MaxIsrWait = 40
ULONG	g_opt_DriveSelectNanoDelay = 0
BOOLEAN	g_opt_AtapiSendDisableIntr = 0
BOOLEAN	g_opt_AtapiDmaRawRead = 1
BOOLEAN	g_opt_AtapiNoDma = FALSE
BOOLEAN	g_opt_BochsDmaReadWorkaround = FALSE
BOOLEAN	hasPCI = FALSE
ULONG	g_opt_VirtualMachine = 0
BOOLEAN	InDriverEntry = TRUE
BOOLEAN	g_Dump = FALSE
BOOLEAN	g_opt_Verbose = 0
BOOLEAN	WinVer_WDM_Model = FALSE
ULONG	CPU_num = 1
UCHAR	g_foo = 0

Macro Definition Documentation

AtapiReadPortBufferN_template

#define AtapiReadPortBufferN_template	(		_type,
			_Type,
			sz
	)

Definition at line 404 of file id_ata.cpp.

AtapiReadPortExN_template

#define AtapiReadPortExN_template	(		_type,
			_Type,
			sz
	)

Value:

_type \
DDKFASTAPI \
AtapiReadPortEx##sz( \
    IN PHW_CHANNEL chan, \
    IN ULONGIO_PTR _port, \
    IN ULONG offs \
    ) \
{ \
    PIORES res; \
    if(_port >= IDX_MAX_REG) { \
        res = (PIORES)(_port);  \
    } else \
    if(chan) { \
        res = &chan->RegTranslation[_port];  \
    } else {                                     \
        KdPrint(("invalid io read request @ ch %x, res* %x, offs %x\n", chan, _port, offs)); \
        return (_type)(-1); \
    } \
    if(res->Proc) {             \
        KdPrint(("PROC io read request @ ch %x, res* %x, offs %x\n", chan, _port, offs)); \
        ASSERT(FALSE); /* We should never get here */ \
    } \
    if(!res->MemIo) {             \
        return ScsiPortReadPort##_Type((_type*)(ULONGIO_PTR)(res->Addr+offs)); \
    } else {                                      \
        /*KdPrint(("r_mem @ (%x) %x\n", _port, port));*/ \
        return ScsiPortReadRegister##_Type((_type*)(ULONG_PTR)(res->Addr+offs)); \
    }                                                        \
}

Definition at line 369 of file id_ata.cpp.

AtapiReadPortN_template

#define AtapiReadPortN_template	(		_type,
			_Type,
			sz
	)

Value:

_type \
DDKFASTAPI \
AtapiReadPort##sz( \
    IN PHW_CHANNEL chan, \
    IN ULONGIO_PTR _port \
    ) \
{ \
    PIORES res; \
    if(_port >= IDX_MAX_REG) { \
        res = (PIORES)(_port);  \
    } else \
    if(chan) { \
        res = &chan->RegTranslation[_port];  \
    } else {                                     \
        KdPrint(("invalid io read request @ ch %x, res* %x\n", chan, _port)); \
        return (_type)(-1); \
    } \
    if(res->Proc) {             \
        KdPrint(("PROC io read request @ ch %x, res* %x\n", chan, _port)); \
        ASSERT(FALSE); /* We should never get here */ \
    } \
    if(!res->MemIo) {             \
        /*KdPrint(("r_io @ (%x) %x\n", _port, res->Addr));*/ \
        return ScsiPortReadPort##_Type((_type*)(ULONGIO_PTR)(res->Addr)); \
    } else {                                      \
        /*KdPrint(("r_mem @ (%x) %x\n", _port, res->Addr));*/ \
        return ScsiPortReadRegister##_Type((_type*)(ULONG_PTR)(res->Addr)); \
    }                                                        \
}

Definition at line 334 of file id_ata.cpp.

AtapiWritePortBufferN_template

#define AtapiWritePortBufferN_template	(		_type,
			_Type,
			sz
	)

Definition at line 449 of file id_ata.cpp.

AtapiWritePortExN_template

#define AtapiWritePortExN_template	(		_type,
			_Type,
			sz
	)

Definition at line 297 of file id_ata.cpp.

AtapiWritePortN_template

#define AtapiWritePortN_template	(		_type,
			_Type,
			sz
	)

Value:

VOID \
DDKFASTAPI \
AtapiWritePort##sz( \
    IN PHW_CHANNEL chan, \
    IN ULONGIO_PTR _port, \
    IN _type  data \
    ) \
{ \
    PIORES res; \
    if(_port >= IDX_MAX_REG) { \
        res = (PIORES)(_port);  \
    } else \
    if(chan) { \
        res = &chan->RegTranslation[_port];  \
    } else {                                     \
        KdPrint(("invalid io write request @ ch %x, res* %x\n", chan, _port)); \
        return; \
    } \
    if(res->Proc) {             \
        KdPrint(("PROC io write request @ ch %x, res* %x\n", chan, _port)); \
        ASSERT(FALSE); /* We should never get here */ \
    } \
    if(!res->MemIo) {             \
        ScsiPortWritePort##_Type((_type*)(ULONGIO_PTR)(res->Addr), data); \
    } else {                                      \
        /*KdPrint(("r_mem @ (%x) %x\n", _port, port));*/ \
        ScsiPortWriteRegister##_Type((_type*)(ULONG_PTR)(res->Addr), data); \
    }                                                        \
    return;                                                  \
}

Definition at line 261 of file id_ata.cpp.

DEBUG_MSG_BUFFER_SIZE

#define DEBUG_MSG_BUFFER_SIZE   512

Definition at line 11684 of file id_ata.cpp.

ITEMS_TO_QUERY [1/2]

#define ITEMS_TO_QUERY   2

ITEMS_TO_QUERY [2/2]

#define ITEMS_TO_QUERY   2

RESET_COMPLETE_ALL

#define RESET_COMPLETE_ALL   0x01

Definition at line 144 of file id_ata.cpp.

RESET_COMPLETE_CURRENT

#define RESET_COMPLETE_CURRENT   0x00

Definition at line 143 of file id_ata.cpp.

RESET_COMPLETE_NONE

#define RESET_COMPLETE_NONE   0x02

Definition at line 145 of file id_ata.cpp.

RETTYPE_XXableInterrupts

#define RETTYPE_XXableInterrupts   VOID

Definition at line 159 of file id_ata.cpp.

RETVAL_XXableInterrupts

#define RETVAL_XXableInterrupts

Definition at line 160 of file id_ata.cpp.

SetCheckPoint

#define SetCheckPoint

(

cp

)

Definition at line 8228 of file id_ata.cpp.

Function Documentation

_PrintNtConsole()

VOID _cdecl _PrintNtConsole	(	PCCH	DebugMessage,
			...
	)

Definition at line 11689 of file id_ata.cpp.

{
    //int len;
    UCHAR dbg_print_tmp_buff[DEBUG_MSG_BUFFER_SIZE];
//    UNICODE_STRING msgBuff;
    va_list ap;
    va_start(ap, DebugMessage);
 
    /*len =*/ _vsnprintf((PCHAR)&dbg_print_tmp_buff[0], DEBUG_MSG_BUFFER_SIZE-1, DebugMessage, ap);
 
    dbg_print_tmp_buff[DEBUG_MSG_BUFFER_SIZE-1] = 0;
 
    //DbgPrint(((PCHAR)&(dbg_print_tmp_buff[0]))); // already done in KdPrint macro
    HalDisplayString(dbg_print_tmp_buff);
 
#ifdef _DEBUG
    if(g_LogToDisplay > 1) {
        AtapiStallExecution(g_LogToDisplay*1000);
    }
#endif // _DEBUG
 
    va_end(ap);
 
} // end PrintNtConsole()

Referenced by DriverEntry().

AtaCommand()

UCHAR NTAPI AtaCommand	(	IN PHW_DEVICE_EXTENSION	deviceExtension,
		IN ULONG	DeviceNumber,
		IN ULONG	lChannel,
		IN UCHAR	command,
		IN USHORT	cylinder,
		IN UCHAR	head,
		IN UCHAR	sector,
		IN UCHAR	count,
		IN UCHAR	feature,
		IN ULONG	wait_flags
	)

Definition at line 1168 of file id_ata.cpp.

{
    if(!(deviceExtension->HwFlags & UNIATA_AHCI)) {
        return AtaCommand48(deviceExtension, DeviceNumber, lChannel,
                            command,
                            (ULONG)sector | ((ULONG)cylinder << 8) | ((ULONG)(head & 0x0f) << 24),
                            count, feature, wait_flags);
    } else {
        return UniataAhciSendPIOCommand(deviceExtension, lChannel, DeviceNumber,
            (PSCSI_REQUEST_BLOCK)NULL,
            NULL,
            0,
            command,
            (ULONG)sector | ((ULONG)cylinder << 8) | ((ULONG)(head & 0x0f) << 24),
            count,
            feature,
            0 /* ahci flags */ ,
            wait_flags,
            1000 /* timeout 1 sec */
            );
 
    }
} // end AtaCommand()

Referenced by AtapiHwInitialize__(), AtapiStartIo__(), IdeMediaStatus(), IdeSendCommand(), IdeSendSmartCommand(), IssueIdentify(), MapError(), and SetDriveParameters().

AtaCommand48()

UCHAR NTAPI AtaCommand48	(	IN PHW_DEVICE_EXTENSION	deviceExtension,
		IN ULONG	DeviceNumber,
		IN ULONG	lChannel,
		IN UCHAR	command,
		IN ULONGLONG	lba,
		IN USHORT	count,
		IN USHORT	feature,
		IN ULONG	wait_flags
	)

Definition at line 968 of file id_ata.cpp.

{
    PHW_CHANNEL          chan = &(deviceExtension->chan[lChannel]);
    UCHAR                statusByte;
    ULONG i;
    PUCHAR plba;
 
    KdPrint2((PRINT_PREFIX "AtaCommand48: cntrlr %#x:%#x dev %#x, cmd %#x, lba %#I64x count %#x feature %#x\n",
                 deviceExtension->DevIndex, deviceExtension->Channel, DeviceNumber, command, lba, count, feature ));
 
    if(deviceExtension->HwFlags & UNIATA_AHCI) {
        //PIDE_AHCI_CMD  AHCI_CMD = &(chan->AhciCtlBlock->cmd);
 
        KdPrint3(("  (ahci)\n"));
 
        statusByte = UniataAhciSendPIOCommand(deviceExtension, lChannel, DeviceNumber,
            (PSCSI_REQUEST_BLOCK)NULL,
            NULL,
            0,
            command,
            lba, count,
            feature,
            0 /* ahci flags */ ,
            wait_flags,
            1000 /* timeout 1 sec */
            );
 
        return statusByte;
    }
 
    SelectDrive(chan, DeviceNumber);
 
    statusByte = WaitOnBusy(chan);
 
    /* ready to issue command ? */
    if (statusByte & IDE_STATUS_BUSY) {
        KdPrint2((PRINT_PREFIX "  Returning BUSY status\n"));
        return statusByte;
    }
    // !!! We should not check ERROR condition here
    // ERROR bit may be asserted durring previous operation
    // and not cleared after SELECT
 
    //>>>>>> NV: 2006/08/03
    if(((AtaCommandFlags[command] & (ATA_CMD_FLAG_LBAIOsupp|ATA_CMD_FLAG_FUA)) == ATA_CMD_FLAG_LBAIOsupp) &&
       CheckIfBadBlock(chan->lun[DeviceNumber], lba, count)) {
        KdPrint3((PRINT_PREFIX ": artificial bad block, lba %#I64x count %#x\n", lba, count));
        return IDE_STATUS_ERROR;
        //return SRB_STATUS_ERROR;
    }
    //<<<<<< NV:  2006/08/03
 
    /* only use 48bit addressing if needed because of the overhead */
    if (UniAta_need_lba48(command, lba, count,
        chan->lun[DeviceNumber]->IdentifyData.FeaturesSupport.Address48)) {
 
        KdPrint2((PRINT_PREFIX "  dev %#x USE_LBA_48\n", DeviceNumber ));
        /* translate command into 48bit version */
        if(AtaCommandFlags[command] & ATA_CMD_FLAG_48supp) {
            command = AtaCommands48[command];
        } else {
            KdPrint2((PRINT_PREFIX "  unhandled LBA48 command\n"));
            return (UCHAR)-1;
        }
 
        chan->ChannelCtrlFlags |= CTRFLAGS_LBA48;
        plba = (PUCHAR)&lba;
 
        AtapiWritePort1(chan, IDX_IO1_o_Feature,      (UCHAR)(feature>>8));
        AtapiWritePort1(chan, IDX_IO1_o_Feature,      (UCHAR)feature);
        AtapiWritePort1(chan, IDX_IO1_o_BlockCount,   (UCHAR)(count>>8));
        AtapiWritePort1(chan, IDX_IO1_o_BlockCount,   (UCHAR)count);
        AtapiWritePort1(chan, IDX_IO1_o_BlockNumber,  (UCHAR)(plba[3]));
        AtapiWritePort1(chan, IDX_IO1_o_BlockNumber,  (UCHAR)(plba[0]));
        AtapiWritePort1(chan, IDX_IO1_o_CylinderLow,  (UCHAR)(plba[4]));
        AtapiWritePort1(chan, IDX_IO1_o_CylinderLow,  (UCHAR)(plba[1]));
        AtapiWritePort1(chan, IDX_IO1_o_CylinderHigh, (UCHAR)(plba[5]));
        AtapiWritePort1(chan, IDX_IO1_o_CylinderHigh, (UCHAR)(plba[2]));
 
        //KdPrint2((PRINT_PREFIX "AtaCommand48: dev %#x USE_LBA48 (2)\n", DeviceNumber ));
        AtapiWritePort1(chan, IDX_IO1_o_DriveSelect, IDE_USE_LBA | (DeviceNumber ? IDE_DRIVE_2 : IDE_DRIVE_1) );
    } else {
 
        plba = (PUCHAR)&lba; //ktp
        chan->ChannelCtrlFlags &= ~CTRFLAGS_LBA48;
 
        //if(feature ||
        //   (chan->lun[DeviceNumber]->DeviceFlags & (DFLAGS_ATAPI_DEVICE | DFLAGS_TAPE_DEVICE | DFLAGS_LBA_ENABLED))) {
            AtapiWritePort1(chan, IDX_IO1_o_Feature,      (UCHAR)feature);
        //}
        AtapiWritePort1(chan, IDX_IO1_o_BlockCount,   (UCHAR)count);
        AtapiWritePort1(chan, IDX_IO1_o_BlockNumber,  (UCHAR)plba[0]);
        AtapiWritePort1(chan, IDX_IO1_o_CylinderLow,  (UCHAR)plba[1]);
        AtapiWritePort1(chan, IDX_IO1_o_CylinderHigh, (UCHAR)plba[2]);
        if(chan->lun[DeviceNumber]->DeviceFlags & DFLAGS_LBA_ENABLED) {
            //KdPrint2((PRINT_PREFIX "AtaCommand28: dev %#x USE_LBA\n", DeviceNumber ));
            AtapiWritePort1(chan, IDX_IO1_o_DriveSelect,  (UCHAR)(plba[3] & 0xf) | IDE_USE_LBA | (DeviceNumber ? IDE_DRIVE_SELECT_2 : IDE_DRIVE_SELECT_1) );
        } else {
            //KdPrint2((PRINT_PREFIX "AtaCommand28: dev %#x USE_CHS\n", DeviceNumber ));
            AtapiWritePort1(chan, IDX_IO1_o_DriveSelect,  (UCHAR)(plba[3] & 0xf) | (DeviceNumber ? IDE_DRIVE_SELECT_2 : IDE_DRIVE_SELECT_1) );
        }
    }
 
    // write command code to device
    AtapiWritePort1(chan, IDX_IO1_o_Command, command);
 
    switch (wait_flags) {
    case ATA_WAIT_INTR:
 
        // caller requested wait for interrupt
        for(i=0;i<4;i++) {
            WaitOnBusy(chan);
            statusByte = WaitForDrq(chan);
            if (statusByte & IDE_STATUS_DRQ)
                break;
            AtapiStallExecution(500);
            KdPrint2((PRINT_PREFIX "  retry waiting DRQ, status %#x\n", statusByte));
        }
 
        return statusByte;
 
    case ATA_WAIT_IDLE:
 
        // caller requested wait for entering Wait state
        for (i=0; i<30 * 1000; i++) {
 
            GetStatus(chan, statusByte);
            statusByte = UniataIsIdle(deviceExtension, statusByte);
            if(statusByte == IDE_STATUS_WRONG) {
                // no drive ?
                break;
            } else
            if(statusByte & IDE_STATUS_ERROR) {
                break;
            } else
            if(statusByte & IDE_STATUS_BUSY) {
                AtapiStallExecution(100);
                continue;
            } else
            if((statusByte & ~IDE_STATUS_INDEX) == IDE_STATUS_IDLE) {
                break;
            } else {
                //if(deviceExtension->HwFlags & UNIATA_SATA) {
                if(UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
                    break;
                }
                AtapiStallExecution(100);
            }
        }
        //statusByte |= IDE_STATUS_BUSY;
        break;
 
    case ATA_WAIT_READY:
        statusByte = WaitOnBusyLong(chan);
        break;
    case ATA_WAIT_BASE_READY:
        statusByte = WaitOnBaseBusyLong(chan);
        break;
    case ATA_IMMEDIATE:
        GetStatus(chan, statusByte);
        if (statusByte & IDE_STATUS_ERROR) {
            KdPrint2((PRINT_PREFIX "  Warning: Immed Status %#x :(\n", statusByte));
            if(statusByte == (IDE_STATUS_IDLE | IDE_STATUS_ERROR)) {
                break;
            }
            KdPrint2((PRINT_PREFIX "  try to continue\n"));
            statusByte &= ~IDE_STATUS_ERROR;
 
        } else {
            //KdPrint2((PRINT_PREFIX "  send Status %#x\n", statusByte));
        }
        UniataExpectChannelInterrupt(chan, TRUE);
        // !!!!!
        InterlockedExchange(&(chan->CheckIntr),
                                      CHECK_INTR_IDLE);
 
        statusByte = IDE_STATUS_SUCCESS;
        break;
    }
 
    //KdPrint2((PRINT_PREFIX "  Status %#x\n", statusByte));
 
    return statusByte;
} // end AtaCommand48()

Referenced by AtaCommand(), IdeReadWrite(), IdeVerify(), and IssueIdentify().

AtapiAdapterControl()

SCSI_ADAPTER_CONTROL_STATUS NTAPI AtapiAdapterControl	(	IN PVOID	HwDeviceExtension,
		IN SCSI_ADAPTER_CONTROL_TYPE	ControlType,
		IN PVOID	Parameters
	)

Definition at line 11585 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PSCSI_SUPPORTED_CONTROL_TYPE_LIST pControlTypeList;
    ULONG                numberChannels  = deviceExtension->NumberChannels;
    ULONG c;
    NTSTATUS status;
 
    KdPrint(( "AtapiAdapterControl: %#x\n", ControlType));
 
    switch(ControlType) {
        case ScsiQuerySupportedControlTypes: {
            BOOLEAN supportedTypes[ScsiAdapterControlMax] = {
                TRUE,       // ScsiQuerySupportedControlTypes
                TRUE,       // ScsiStopAdapter
                TRUE,       // ScsiRestartAdapter
                FALSE,      // ScsiSetBootConfig
                FALSE       // ScsiSetRunningConfig
            };
 
            ULONG lim = ScsiAdapterControlMax;
            ULONG i;
 
            pControlTypeList = (PSCSI_SUPPORTED_CONTROL_TYPE_LIST) Parameters;
 
            if(pControlTypeList->MaxControlType < lim) {
                lim = pControlTypeList->MaxControlType;
            }
 
            for(i = 0; i < lim; i++) {
                pControlTypeList->SupportedTypeList[i] = supportedTypes[i];
            }
 
            break;
 
        }
        case ScsiStopAdapter: {
 
            KdPrint(( "AtapiAdapterControl: ScsiStopAdapter\n"));
            // Shut down all interrupts on the adapter.  They'll get re-enabled
            // by the initialization routines.
            for (c = 0; c < numberChannels; c++) {
                AtapiResetController(deviceExtension, c);
                AtapiDisableInterrupts(deviceExtension, c);
            }
            if(deviceExtension->AdapterInterfaceType == PCIBus) {
                // we must never get here for non-PCI
                /*status =*/ UniataDisconnectIntr2(HwDeviceExtension);
                BMList[deviceExtension->DevIndex].Isr2Enable = FALSE;
            }
            break;
        }
        case ScsiRestartAdapter: {
 
            KdPrint(( "AtapiAdapterControl: ScsiRestartAdapter\n"));
            // Enable all the interrupts on the adapter while port driver call
            // for power up an HBA that was shut down for power management
 
            AtapiChipInit(HwDeviceExtension, DEVNUM_NOT_SPECIFIED, CHAN_NOT_SPECIFIED);
            status = UniataConnectIntr2(HwDeviceExtension);
            if(NT_SUCCESS(status)) {
                for (c = 0; c < numberChannels; c++) {
                    AtapiChipInit(HwDeviceExtension, DEVNUM_NOT_SPECIFIED, c);
                    FindDevices(HwDeviceExtension, 0, c);
                    AtapiEnableInterrupts(deviceExtension, c);
                    AtapiHwInitialize__(deviceExtension, c);
                }
                if(deviceExtension->Isr2DevObj) {
                    // we must never get here for non-PCI
                    BMList[deviceExtension->DevIndex].Isr2Enable = TRUE;
                }
            }
 
            break;
        }
 
        default: {
            KdPrint(( "AtapiAdapterControl: default => return ScsiAdapterControlUnsuccessful\n"));
            return ScsiAdapterControlUnsuccessful;
        }
    }
 
    return ScsiAdapterControlSuccess;
} // end AtapiAdapterControl()

Referenced by DriverEntry().

AtapiCallBack__()

VOID NTAPI AtapiCallBack__	(	IN PVOID	HwDeviceExtension,
		IN UCHAR	lChannel
	)

Definition at line 3872 of file id_ata.cpp.

{
 
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PHW_CHANNEL chan = &(deviceExtension->chan[lChannel]);
    ULONG c, _c;
 
    PSCSI_REQUEST_BLOCK  srb = UniataGetCurRequest(chan);
    UCHAR statusByte;
 
    KdPrint2((PRINT_PREFIX "AtapiCallBack:\n"));
    // If the last command was DSC restrictive, see if it's set. If so, the device is
    // ready for a new request. Otherwise, reset the timer and come back to here later.
 
    // If ISR decided to wait for BUSY or DRQ in DPC, we shall also get here.
    // In this case chan->ExpectingInterrupt == TRUE, but interrupts are disabled, thus,
    // we shall have no problem with interrupt handler.
    if (!srb || chan->ExpectingInterrupt) {
        KdPrint2((PRINT_PREFIX "AtapiCallBack: Calling ISR directly due to BUSY\n"));
        chan->DpcState = DPC_STATE_TIMER;
        if(!AtapiInterrupt__(HwDeviceExtension, lChannel)) {
            InterlockedExchange(&(chan->CheckIntr), CHECK_INTR_IDLE);
            KdPrint2((PRINT_PREFIX "AtapiCallBack: What's fucking this ???\n"));
        }
        goto ReturnCallback;
    }
 
#ifdef _DEBUG
    if (!IS_RDP((srb->Cdb[0]))) {
        KdPrint2((PRINT_PREFIX "AtapiCallBack: Invalid CDB marked as RDP - %#x\n", srb->Cdb[0]));
    }
#endif
    if(!(chan->RDP)) {
        goto ReturnEnableIntr;
    }
    GetStatus(chan, statusByte);
    if (statusByte & IDE_STATUS_DSC) {
 
        UCHAR PathId   = srb->PathId;
        UCHAR TargetId = srb->TargetId;
        UCHAR Lun      = srb->Lun;
 
        KdPrint2((PRINT_PREFIX "AtapiCallBack: Found DSC for RDP - %#x\n", srb->Cdb[0]));
        AtapiDmaDBSync(chan, srb);
        UniataRemoveRequest(chan, srb);
        ScsiPortNotification(RequestComplete, deviceExtension, srb);
        // Clear current SRB.
        if(!deviceExtension->simplexOnly) {
            srb = UniataGetCurRequest(chan);
        } else {
            srb = NULL;
        }
        chan->RDP = FALSE;
 
        // Ask for next request.
        ScsiPortNotification(NextLuRequest,
                             deviceExtension,
                             PathId,
                             TargetId,
                             Lun);
        ScsiPortNotification(NextRequest, deviceExtension, NULL);
 
        if(srb) {
            AtapiStartIo__(HwDeviceExtension, srb, FALSE);
        }
 
    } else {
        KdPrint2((PRINT_PREFIX "AtapiCallBack: Requesting another timer for Op %#x\n",
                    srb->Cdb[0]));
 
        AtapiQueueTimerDpc(HwDeviceExtension, lChannel,
                             AtapiCallBack_X,
                             1000);
 
        goto ReturnCallback;
    }
 
ReturnEnableIntr:
 
    if(CrNtInterlockedExchangeAdd(&(chan->DisableIntr), 0)) {
        KdPrint2((PRINT_PREFIX "AtapiCallBack: CallDisableInterrupts\n"));
        //ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
#ifdef UNIATA_USE_XXableInterrupts
        chan->ChannelCtrlFlags |= CTRFLAGS_ENABLE_INTR_REQ;
        // must be called on DISPATCH_LEVEL
        ScsiPortNotification(CallDisableInterrupts, HwDeviceExtension,
                             AtapiEnableInterrupts__);
#else
        AtapiEnableInterrupts(HwDeviceExtension, lChannel);
        InterlockedExchange(&(chan->CheckIntr),
                                      CHECK_INTR_IDLE);
        // Will raise IRQL to DIRQL
        AtapiQueueTimerDpc(HwDeviceExtension, lChannel,
                             AtapiEnableInterrupts__,
                             1);
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: Timer DPC inited\n"));
#endif // UNIATA_USE_XXableInterrupts
    } else {
        //ASSERT(!deviceExtension->simplexOnly);
    }
 
ReturnCallback:
 
    // Check other channel
    // In simplex mode no interrupts must appear on other channels
    for(_c=0; _c<deviceExtension->NumberChannels; _c++) {
        c = (_c+deviceExtension->FirstChannelToCheck) % deviceExtension->NumberChannels;
 
        if(c == lChannel) {
            continue;
        }
 
        chan = &(deviceExtension->chan[c]);
 
        if((ULONG)CrNtInterlockedCompareExchange(CRNT_ILK_PTYPE &(chan->CheckIntr),
                                      CRNT_ILK_TYPE CHECK_INTR_ACTIVE,
                                      CRNT_ILK_TYPE CHECK_INTR_DETECTED) == CHECK_INTR_DETECTED)
        {
            //ASSERT(!deviceExtension->simplexOnly);
            chan->DpcState = DPC_STATE_ISR;
            if(!AtapiInterrupt__(HwDeviceExtension, (UCHAR)c)) {
                InterlockedExchange(&(chan->CheckIntr), CHECK_INTR_IDLE);
            }
        }
    }
    KdPrint2((PRINT_PREFIX "AtapiCallBack: return\n"));
    return;
 
} // end AtapiCallBack__()

Referenced by AtapiCallBack_X().

AtapiCallBack_X()

VOID NTAPI AtapiCallBack_X

(

IN PVOID

HwDeviceExtension

)

Definition at line 4007 of file id_ata.cpp.

{
    AtapiCallBack__(HwDeviceExtension, (UCHAR)((PHW_DEVICE_EXTENSION)HwDeviceExtension)->ActiveDpcChan);
} // end AtapiCallBack_X()

Referenced by AtapiCallBack__(), and AtapiInterrupt__().

AtapiCheckInterrupt__()

BOOLEAN NTAPI AtapiCheckInterrupt__	(	IN PVOID	HwDeviceExtension,
		IN UCHAR	c
	)

• clear interrupt and get status *‍/

Definition at line 4512 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PHW_CHANNEL chan = &(deviceExtension->chan[c]);
    PHW_LU_EXTENSION LunExt;
 
    ULONG VendorID  = deviceExtension->DevID & 0xffff;
    ULONG ChipType  = deviceExtension->HwFlags & CHIPTYPE_MASK;
 
    ULONG status;
    ULONG pr_status = 0;
    UCHAR dma_status = 0;
    UCHAR reg8 = 0;
    ULONG reg32 = 0;
    UCHAR statusByte = 0;
    ULONG slotNumber = deviceExtension->slotNumber;
    ULONG SystemIoBusNumber = deviceExtension->SystemIoBusNumber;
    ULONG ChipFlags = deviceExtension->HwFlags & CHIPFLAG_MASK;
    UCHAR Channel;
    UCHAR lChannel;
    BOOLEAN DmaTransfer = FALSE;
    BOOLEAN OurInterrupt = FALSE;
    BOOLEAN StatusValid = FALSE;
//    ULONG k;
    UCHAR interruptReason;
    BOOLEAN EarlyIntr = FALSE;
    BOOLEAN SingleBlockIntr = FALSE;
 
    KdPrint2((PRINT_PREFIX "AtapiCheckInterrupt__:\n"));
 
    lChannel = c;
    Channel = (UCHAR)(deviceExtension->Channel + lChannel);
    LunExt = chan->lun[chan->cur_cdev];
 
    //KdPrint2((PRINT_PREFIX "AtapiCheckInterrupt__ chan %#x:\n", chan));
    //KdPrint2((PRINT_PREFIX "AtapiCheckInterrupt__ (%d/%d):\n", Channel, chan->cur_cdev));
 
    if((ChipFlags & UNIATA_AHCI) &&
        UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
 
        if(!UniataAhciChanImplemented(deviceExtension, lChannel)) {
            return OurInterrupt;
        }
 
        OurInterrupt = UniataAhciStatus(HwDeviceExtension, lChannel, DEVNUM_NOT_SPECIFIED);
        if((OurInterrupt == INTERRUPT_REASON_UNEXPECTED) &&
           (LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE)) {
            UniataAhciWaitCommandReady(chan, 2 /* ms */ );
            statusByte = (UCHAR)UniataAhciWaitReady(chan, 0 /* immediate */);
            if(!(statusByte & (IDE_STATUS_BUSY)) ) {
                KdPrint2((PRINT_PREFIX "ATAPI special case READY\n"));
                //deviceExtension->ExpectingInterrupt++; // will be updated in ISR on ReturnEnableInterrupts
                OurInterrupt = INTERRUPT_REASON_OUR;
            } else
            if((statusByte & (IDE_STATUS_BUSY | IDE_STATUS_DRDY)) == (IDE_STATUS_BUSY | IDE_STATUS_DRDY) ) {
                KdPrint2((PRINT_PREFIX "ATAPI special case pre ERR-READY\n"));
                OurInterrupt = INTERRUPT_REASON_OUR;
            } else
            if(statusByte & IDE_STATUS_ERROR) {
                KdPrint2((PRINT_PREFIX "ATAPI special case ERR-READY\n"));
                OurInterrupt = INTERRUPT_REASON_OUR;
            } else {
                KdPrint2((PRINT_PREFIX "ATAPI special case ? %x\n", statusByte));
                OurInterrupt = INTERRUPT_REASON_OUR;
            }
        }
        return OurInterrupt;
    }
 
    if(chan->ChannelCtrlFlags & CTRFLAGS_DMA_ACTIVE) {
        DmaTransfer = TRUE;
        KdPrint2((PRINT_PREFIX "  cntrlr %#x:%#x, lch %#x DmaTransfer = TRUE\n", deviceExtension->DevIndex,
            deviceExtension->Channel + c, c));
    } else {
        KdPrint2((PRINT_PREFIX "  cntrlr %#x:%#x, lch %#x DmaTransfer = FALSE\n", deviceExtension->DevIndex,
            deviceExtension->Channel + c, c));
        dma_status = GetDmaStatus(deviceExtension, lChannel);
        KdPrint2((PRINT_PREFIX "  DMA status %#x\n", dma_status));
    }
 
    // do controller-specific interrupt servicing staff
    if(deviceExtension->UnknownDev) {
        KdPrint2((PRINT_PREFIX "  UnknownDev\n"));
        goto check_unknown;
    }
 
    // Attention !
    // We can catch (BM_STATUS_ACTIVE + BM_STATUS_INTR) when operation is actually completed
    // Such behavior was observed with Intel ICH-xxx chips
    // This condition shall also be treated as 'our interrupt' because of BM_STATUS_INTR flag
 
    switch(VendorID) {
 
    case ATA_PROMISE_ID: {
        switch(ChipType) {
        case PROLD:
        case PRNEW:
            status = AtapiReadPortEx4(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressBM_0),0x1c);
            if (!DmaTransfer)
                break;
            if (!(status &
                  ((Channel) ? 0x00004000 : 0x00000400))) {
                KdPrint2((PRINT_PREFIX "  Promise old/new unexpected\n"));
                return INTERRUPT_REASON_IGNORE;
            }
            break;
        case PRTX:
            AtapiWritePort1(chan, IDX_BM_DeviceSpecific0, 0x0b);
            status = AtapiReadPort1(chan, IDX_BM_DeviceSpecific1);
            if (!DmaTransfer)
                break;
            if(!(status & 0x20)) {
                KdPrint2((PRINT_PREFIX "  Promise tx unexpected\n"));
                return INTERRUPT_REASON_IGNORE;
            }
            break;
        case PRMIO: {
            ULONG stat_reg = (ChipFlags & PRG2) ? 0x60 : 0x6c;
            status = AtapiReadPortEx4(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressBM_0),0x40);
            AtapiWritePortEx4(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressBM_0),0x40, status);
 
            if(status & (1 << (Channel+1))) {
                // our
            } else {
                KdPrint2((PRINT_PREFIX "  Promise mio unexpected\n"));
                return INTERRUPT_REASON_IGNORE;
            }
 
            if(!(ChipFlags & UNIATA_SATA))
                break;
 
            pr_status = AtapiReadPortEx4(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressBM_0),stat_reg);
            AtapiWritePortEx4(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressBM_0),stat_reg, (pr_status & (0x11 << Channel)));
            if(pr_status & (0x11 << Channel)) {
                // TODO: reset channel
                KdPrint2((PRINT_PREFIX "  Promise mio unexpected + reset req\n"));
                UniataSataEvent(deviceExtension, lChannel, UNIATA_SATA_EVENT_DETACH, 0);
            }
            if(!(status & (0x01 << Channel))) {
                // Connect event
                KdPrint2((PRINT_PREFIX "  Promise mio unexpected attach\n"));
                UniataSataEvent(deviceExtension, lChannel, UNIATA_SATA_EVENT_ATTACH, 0);
            }
            if(UniataSataClearErr(HwDeviceExtension, c, UNIATA_SATA_DO_CONNECT, 0)) {
                OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
            } else {
                return INTERRUPT_REASON_IGNORE;
            }
 
            AtapiWritePort4(chan, IDX_BM_DeviceSpecific0, 0x00000001);
            break; }
        }
        break; }
    case ATA_NVIDIA_ID: {
        if(!(ChipFlags & UNIATA_SATA) || (ChipFlags & NVGEN))
            break;
 
        KdPrint2((PRINT_PREFIX "NVIDIA\n"));
 
        ULONG offs = (ChipFlags & NV4OFF) ? 0x0440 : 0x0010;
        ULONG shift = Channel * ((ChipFlags & NVQ) ? 4 : 16);
 
        /* get and clear interrupt status */
        if(ChipFlags & NVQ) {
            pr_status = AtapiReadPortEx4(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs);
            AtapiWritePortEx4(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs, (0x0fUL << shift) | 0x00f000f0);
        } else {
            pr_status = AtapiReadPortEx1(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs);
            AtapiWritePortEx1(chan, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs, (0x0f << shift));
        }
        KdPrint2((PRINT_PREFIX "  pr_status %x, shift %x\n", pr_status, shift));
 
        /* check for and handle connect events */
        if(((pr_status & (0x0cUL << shift)) == (0x04UL << shift)) ) {
            UniataSataEvent(deviceExtension, lChannel, UNIATA_SATA_EVENT_ATTACH, 0);
        }
        /* check for and handle disconnect events */
        if((pr_status & (0x08UL << shift)) &&
            !((pr_status & (0x04UL << shift) &&
            UniataSataReadPort4(chan, IDX_SATA_SStatus, 0))) ) {
            UniataSataEvent(deviceExtension, lChannel, UNIATA_SATA_EVENT_DETACH, 0);
        }
        /* do we have any device action ? */
        if(!(pr_status & (0x01UL << shift))) {
            KdPrint2((PRINT_PREFIX "  nVidia unexpected\n"));
            if(UniataSataClearErr(HwDeviceExtension, c, UNIATA_SATA_DO_CONNECT, 0)) {
                OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
            } else {
                return INTERRUPT_REASON_IGNORE;
            }
        }
 
        break; }
    case ATA_ATI_ID:
        KdPrint2((PRINT_PREFIX "ATI\n"));
        if(ChipType == SIIMIO) {
            // fall to SiI
        } else {
            break;
        }
    case ATA_SILICON_IMAGE_ID:
 
        if(ChipType == SIIMIO) {
 
            reg32 = AtapiReadPort4(chan, IDX_BM_DeviceSpecific0);
            KdPrint2((PRINT_PREFIX "  Sii DS0 %x\n", reg32));
            if(reg32 == 0xffffffff) {
                KdPrint2((PRINT_PREFIX "  Sii mio unexpected\n"));
                return INTERRUPT_REASON_IGNORE;
            }
            if(!(reg32 & (BM_DS0_SII_DMA_SATA_IRQ | BM_DS0_SII_DMA_COMPLETE | BM_DS0_SII_IRQ | BM_DS0_SII_DMA_ENABLE | BM_DS0_SII_DMA_ERROR))) {
                KdPrint2((PRINT_PREFIX "  Sii mio unexpected (2)\n"));
                return INTERRUPT_REASON_IGNORE;
            }
 
            if(ChipFlags & UNIATA_SATA) {
                if(reg32 & (BM_DS0_SII_DMA_SATA_IRQ | BM_DS0_SII_IRQ)) {
 
                    /* SIEN doesn't mask SATA IRQs on some 3112s.  Those
                    * controllers continue to assert IRQ as long as
                    * SError bits are pending.  Clear SError immediately.
                    */
                    if(UniataSataClearErr(HwDeviceExtension, c, UNIATA_SATA_DO_CONNECT, 0)) {
                        OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
                    }
                }
            }
 
            if (!DmaTransfer)
                break;
            if (!((dma_status = GetDmaStatus(deviceExtension, lChannel)) & BM_STATUS_INTR)) {
                KdPrint2((PRINT_PREFIX "  Sii mio unexpected (3)\n"));
                return OurInterrupt;
            }
            AtapiWritePort1(chan, IDX_BM_Status, dma_status & ~BM_STATUS_ERR);
            goto skip_dma_stat_check;
 
        } else {
            if(!(deviceExtension->HwFlags & SIIINTR))
                break;
            GetPciConfig1(0x71, reg8);
            KdPrint2((PRINT_PREFIX "  0x71 = %#x\n", reg8));
            if (!(reg8 &
                  (Channel ? 0x08 : 0x04))) {
                return INTERRUPT_REASON_IGNORE;
            }
            if (!DmaTransfer) {
                KdPrint2((PRINT_PREFIX "  cmd our\n"));
                OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
            }
            SetPciConfig1(0x71, (Channel ? 0x08 : 0x04));
        }
        break;
 
    case ATA_ACARD_ID:
        if (!DmaTransfer)
            break;
        //dma_status = GetDmaStatus(deviceExtension, lChannel);
        if (!((dma_status = GetDmaStatus(deviceExtension, lChannel)) & BM_STATUS_INTR)) {
            KdPrint2((PRINT_PREFIX "  Acard unexpected\n"));
            return INTERRUPT_REASON_IGNORE;
        }
        AtapiWritePort1(chan, IDX_BM_Status, dma_status | BM_STATUS_INTR);
        AtapiStallExecution(1);
        AtapiWritePort1(chan, IDX_BM_Command,
            AtapiReadPort1(chan, IDX_BM_Command) & ~BM_COMMAND_START_STOP);
        goto skip_dma_stat_check;
    case ATA_INTEL_ID:
        if(UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
            if(ChipFlags & UNIATA_AHCI) {
                // Do nothing here
            } else
            if(ChipFlags & UNIATA_SATA) {
                if(UniataSataClearErr(HwDeviceExtension, c, UNIATA_SATA_DO_CONNECT, 0)) {
                    OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
                }
                if(!(chan->ChannelCtrlFlags & CTRFLAGS_NO_SLAVE)) {
                    if(UniataSataClearErr(chan->DeviceExtension, chan->lChannel, UNIATA_SATA_IGNORE_CONNECT, 1)) {
                        OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
                    }
                }
            }
        }
        break;
    default:
        if(UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
            if(ChipFlags & UNIATA_AHCI) {
                // Do nothing here
            } else
            if(ChipFlags & UNIATA_SATA) {
                if(UniataSataClearErr(HwDeviceExtension, c, UNIATA_SATA_DO_CONNECT, 0)) {
                    OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
                }
            }
        }
    }
check_unknown:
    KdPrint2((PRINT_PREFIX "  perform generic check\n"));
    if (DmaTransfer) {
        if (!((dma_status = GetDmaStatus(deviceExtension, lChannel)) & BM_STATUS_INTR)) {
            KdPrint2((PRINT_PREFIX "  DmaTransfer + !BM_STATUS_INTR (%x)\n", dma_status));
            if(dma_status & BM_STATUS_ERR) {
                KdPrint2((PRINT_PREFIX "  DmaTransfer + BM_STATUS_ERR -> our\n"));
                OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
            } else {
                KdPrint2((PRINT_PREFIX "  getting status...\n"));
                GetStatus(chan, statusByte);
                StatusValid = 1;
                KdPrint2((PRINT_PREFIX "  status %#x\n", statusByte));
                if(statusByte & IDE_STATUS_ERROR) {
                    KdPrint2((PRINT_PREFIX "  IDE_STATUS_ERROR -> our\n", statusByte));
                    OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
                } else
                if ((statusByte & IDE_STATUS_DSC) &&
                    (LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) &&
                    (dma_status == BM_STATUS_ACTIVE)) {
                    KdPrint2((PRINT_PREFIX "  special case DMA + ATAPI + IDE_STATUS_DSC -> our\n", statusByte));
                    // some devices interrupts on each block transfer even in DMA mode
                    if(LunExt->TransferMode >= ATA_SDMA && LunExt->TransferMode <= ATA_WDMA2) {
                        KdPrint2((PRINT_PREFIX "  wait for completion\n"));
                        //GetBaseStatus(chan, statusByte);
                        //return INTERRUPT_REASON_IGNORE;
                        SingleBlockIntr = TRUE;
                    }
                } else {
                    return INTERRUPT_REASON_IGNORE;
                }
            }
        }
    } else {
        if(dma_status & BM_STATUS_INTR) {
            // bullshit, we have DMA interrupt, but had never initiate DMA operation
            KdPrint2((PRINT_PREFIX "  clear unexpected DMA intr\n"));
            AtapiDmaDone(deviceExtension, DEVNUM_NOT_SPECIFIED ,lChannel, NULL);
            // catch it !
            OurInterrupt = INTERRUPT_REASON_UNEXPECTED;
        }
    }
skip_dma_stat_check:
    if(!(ChipFlags & UNIATA_SATA) && chan->ExpectingInterrupt) {
        AtapiStallExecution(1);
    }
 
    /* if drive is busy it didn't interrupt */
    /* the exception is DCS + BSY state of ATAPI devices */
    if(!StatusValid) {
        KdPrint2((PRINT_PREFIX "  getting status...\n"));
        GetStatus(chan, statusByte);
    }
    if(LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) {
        KdPrint3((PRINT_PREFIX "  ATAPI status %#x\n", statusByte));
    } else {
        KdPrint2((PRINT_PREFIX "  IDE status %#x\n", statusByte));
    }
    if (statusByte == IDE_STATUS_WRONG) {
        // interrupt from empty controller ?
    } else
    if (statusByte & IDE_STATUS_BUSY) {
        if(!chan->ExpectingInterrupt) {
            KdPrint3((PRINT_PREFIX "  unexpected intr + BUSY\n"));
            return OurInterrupt;
        }
 
        if(LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) {
            KdPrint2((PRINT_PREFIX "  ATAPI additional check\n"));
        } else {
            KdPrint2((PRINT_PREFIX "  expecting intr + BUSY (3), non ATAPI\n"));
            return INTERRUPT_REASON_IGNORE;
        }
        if((statusByte & ~(IDE_STATUS_DRQ | IDE_STATUS_INDEX)) !=
           (IDE_STATUS_BUSY | IDE_STATUS_DRDY | IDE_STATUS_DSC)) {
            KdPrint3((PRINT_PREFIX "  unexpected status, seems it is not our\n"));
            return INTERRUPT_REASON_IGNORE;
        }
        if(!(LunExt->DeviceFlags & DFLAGS_INT_DRQ) && (statusByte & IDE_STATUS_DRQ)) {
            KdPrint3((PRINT_PREFIX "  unexpected DRQ, seems it is not our\n"));
            return INTERRUPT_REASON_IGNORE;
        }
 
        EarlyIntr = TRUE;
 
        if(dma_status & BM_STATUS_INTR) {
            KdPrint3((PRINT_PREFIX "  our interrupt with BSY set, try wait in ISR or post to DPC\n"));
            /* clear interrupt and get status */
            GetBaseStatus(chan, statusByte);
            if(!(dma_status & BM_STATUS_ACTIVE)) {
                AtapiDmaDone(deviceExtension, DEVNUM_NOT_SPECIFIED ,lChannel, NULL);
            }
            KdPrint3((PRINT_PREFIX "  base status %#x (+BM_STATUS_INTR)\n", statusByte));
            return INTERRUPT_REASON_OUR;
        }
 
        if(g_WaitBusyInISR) {
            GetStatus(chan, statusByte);
            KdPrint2((PRINT_PREFIX "  status re-check %#x\n", statusByte));
            reg8 = AtapiReadPort1(chan, IDX_IO1_i_Error);
            KdPrint2((PRINT_PREFIX "  Error reg (%#x)\n", reg8));
            if (!(statusByte & IDE_STATUS_BUSY)) {
                KdPrint2((PRINT_PREFIX "  expecting intr + cleared BUSY\n"));
            }
            if (statusByte & IDE_STATUS_BUSY) {
                KdPrint2((PRINT_PREFIX "  still BUSY, seems it is not our\n"));
                return INTERRUPT_REASON_IGNORE;
            }
        }
 
    }
 
    /* clear interrupt and get status */
    GetBaseStatus(chan, statusByte);
    KdPrint2((PRINT_PREFIX "  base status %#x\n", statusByte));
    if (statusByte == IDE_STATUS_WRONG) {
        // interrupt from empty controller ?
    } else
    if(!(statusByte & (IDE_STATUS_DRQ | IDE_STATUS_DRDY))) {
        KdPrint2((PRINT_PREFIX "  no DRQ/DRDY set\n"));
        return OurInterrupt;
    }
 
#ifndef UNIATA_PIO_ONLY
    if(DmaTransfer) {
        if(!SingleBlockIntr && (!EarlyIntr || g_WaitBusyInISR)) {
            dma_status = AtapiDmaDone(HwDeviceExtension, DEVNUM_NOT_SPECIFIED, lChannel, NULL/*srb*/);
        } else {
            PSCSI_REQUEST_BLOCK srb = UniataGetCurRequest(chan);
            PATA_REQ AtaReq = srb ? (PATA_REQ)(srb->SrbExtension) : NULL;
 
            //ASSERT(AtaReq);
 
            if(SingleBlockIntr) {
                KdPrint2((PRINT_PREFIX "  set REQ_STATE_ATAPI_EXPECTING_DATA_INTR2.\n"));
            } else {
                KdPrint2((PRINT_PREFIX "  set REQ_STATE_EARLY_INTR.\n"));
            }
            if(AtaReq) {
                AtaReq->ReqState = SingleBlockIntr ? REQ_STATE_ATAPI_EXPECTING_DATA_INTR2 : REQ_STATE_EARLY_INTR;
            }
        }
    }
#endif //
 
    if (!(chan->ExpectingInterrupt)) {
 
        KdPrint2((PRINT_PREFIX "  Unexpected interrupt.\n"));
 
        if(LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) {
            KdPrint2((PRINT_PREFIX "  ATAPI additional check\n"));
        } else {
            KdPrint2((PRINT_PREFIX "  OurInterrupt = %d\n", OurInterrupt));
            return OurInterrupt;
        }
        interruptReason = (AtapiReadPort1(chan, IDX_ATAPI_IO1_i_InterruptReason) & ATAPI_IR_Mask);
        KdPrint3((PRINT_PREFIX "AtapiCheckInterrupt__: ATAPI int reason %x\n", interruptReason));
        return OurInterrupt;
    }
    //ASSERT(!chan->queue_depth || chan->cur_req);
 
    KdPrint2((PRINT_PREFIX "AtapiCheckInterrupt__: exit with TRUE\n"));
    return INTERRUPT_REASON_OUR;
 
} // end AtapiCheckInterrupt__()

Referenced by AtapiInterrupt(), AtapiInterrupt2(), and IdeSendCommand().

AtapiDisableInterrupts()

VOID NTAPI AtapiDisableInterrupts	(	IN PVOID	HwDeviceExtension,
		IN ULONG	c
	)

Definition at line 4457 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PHW_CHANNEL chan;
    if(c >= deviceExtension->NumberChannels) {
        KdPrint2((PRINT_PREFIX "AtapiDisableInterrupts_%d: WRONG CHANNEL\n",c));
        return;
    }
    chan = &(deviceExtension->chan[c]);
    KdPrint2((PRINT_PREFIX "AtapiDisableInterrupts_%d: %d\n",c, chan->DisableIntr));
    // mark channel as busy
    if(InterlockedIncrement(&chan->DisableIntr)) {
        if(deviceExtension->HwFlags & UNIATA_AHCI) {
            UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE, 0);
        } else {
            //SelectDrive(chan, 0);
            AtapiWritePort1(chan, IDX_IO2_o_Control,
                                   IDE_DC_DISABLE_INTERRUPTS /*| IDE_DC_A_4BIT*/ );
            //if(chan->NumberLuns) {
            //    SelectDrive(chan, 1);
            //    AtapiWritePort1(chan, IDX_IO2_o_Control,
            //                           IDE_DC_DISABLE_INTERRUPTS /*| IDE_DC_A_4BIT*/ );
            //    SelectDrive(chan, chan->cur_cdev);
            //}
        }
        chan->ChannelCtrlFlags |= CTRFLAGS_INTR_DISABLED;
    }
 
    return;
} // end AtapiDisableInterrupts()

Referenced by AtapiAdapterControl(), AtapiHwInitialize__(), AtapiInterrupt(), AtapiInterrupt__(), AtapiResetController__(), AtapiSendCommand(), AtapiStartIo__(), AtaSetTransferMode(), FindDevices(), IdeSendCommand(), IssueIdentify(), and UniataUserDeviceReset().

AtapiEnableInterrupts()

VOID NTAPI AtapiEnableInterrupts	(	IN PVOID	HwDeviceExtension,
		IN ULONG	c
	)

Definition at line 4397 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PHW_CHANNEL chan;
    //UCHAR statusByte;
 
    if(c >= deviceExtension->NumberChannels) {
        KdPrint2((PRINT_PREFIX "AtapiEnableInterrupts_%d: WRONG CHANNEL\n",c));
        return;
    }
    if((deviceExtension->HwFlags & UNIATA_AHCI) &&
       !UniataAhciChanImplemented(deviceExtension, c)) {
        KdPrint2((PRINT_PREFIX "AtapiEnableInterrupts_%d: not imp. CHANNEL\n",c));
        return;
    }
 
    chan = &(deviceExtension->chan[c]);
    KdPrint2((PRINT_PREFIX "AtapiEnableInterrupts_%d: %d\n",c, chan->DisableIntr));
    if(!InterlockedDecrement(&chan->DisableIntr)) {
        if(deviceExtension->HwFlags & UNIATA_AHCI) {
            UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE,
                (ATA_AHCI_P_IX_CPD | ATA_AHCI_P_IX_TFE | ATA_AHCI_P_IX_HBF |
                 ATA_AHCI_P_IX_HBD | ATA_AHCI_P_IX_INF | ATA_AHCI_P_IX_IF | ATA_AHCI_P_IX_OF |
                 ((/*ch->pm_level == */0) ? ATA_AHCI_P_IX_PRC | ATA_AHCI_P_IX_PC : 0) |
                 ATA_AHCI_P_IX_PRC | ATA_AHCI_P_IX_PC | /* DEBUG */
                 ATA_AHCI_P_IX_DI |
                 ATA_AHCI_P_IX_DP | ATA_AHCI_P_IX_UF | ATA_AHCI_P_IX_SDB |
                 ATA_AHCI_P_IX_DS | ATA_AHCI_P_IX_PS | ATA_AHCI_P_IX_DHR)
                );
        } else {
            //SelectDrive(chan, 0);
            //GetBaseStatus(chan, statusByte);
            AtapiWritePort1(chan, IDX_IO2_o_Control,
                                   0 | IDE_DC_A_4BIT );
            //if(chan->NumberLuns) {
            //    SelectDrive(chan, 1);
            //    GetBaseStatus(chan, statusByte);
            //    AtapiWritePort1(chan, IDX_IO2_o_Control,
            //                           IDE_DC_A_4BIT );
            //    SelectDrive(chan, chan->cur_cdev);
            //}
        }
        chan->ChannelCtrlFlags &= ~CTRFLAGS_INTR_DISABLED;
    } else {
        if(deviceExtension->HwFlags & UNIATA_AHCI) {
            // keep interrupts disabled
            UniataAhciWriteChannelPort4(chan, IDX_AHCI_P_IE, 0);
        } else {
            AtapiWritePort1(chan, IDX_IO2_o_Control,
                               IDE_DC_DISABLE_INTERRUPTS /*| IDE_DC_A_4BIT*/ );
        }
    }
    return;
} // end AtapiEnableInterrupts()

Referenced by AtapiAdapterControl(), AtapiCallBack__(), AtapiEnableInterrupts__(), AtapiHwInitialize__(), AtapiInterrupt(), AtapiInterrupt__(), AtapiResetController__(), AtapiSendCommand(), AtapiStartIo__(), AtaSetTransferMode(), FindDevices(), IdeSendCommand(), IssueIdentify(), and UniataUserDeviceReset().

AtapiEnableInterrupts__()

RETTYPE_XXableInterrupts NTAPI AtapiEnableInterrupts__

(

IN PVOID

HwDeviceExtension

)

Definition at line 4333 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    KdPrint2((PRINT_PREFIX "AtapiEnableInterrupts__():\n"));
    ULONG c;
    PHW_CHANNEL chan = NULL;
 
    for(c=0; c<deviceExtension->NumberChannels; c++) {
        KdPrint2((PRINT_PREFIX "AtapiEnableInterrupts__(2): %#x\n",c));
        chan = &(deviceExtension->chan[c]);
 
        if(chan->ChannelCtrlFlags & CTRFLAGS_ENABLE_INTR_REQ) {
            // enable intrs on requested channel
            chan->ChannelCtrlFlags &= ~CTRFLAGS_ENABLE_INTR_REQ;
            AtapiEnableInterrupts(HwDeviceExtension, c);
            InterlockedExchange(&(chan->CheckIntr),
                                          CHECK_INTR_IDLE);
 
            // check if current or other channel(s) interrupted
            //AtapiInterrupt(HwDeviceExtension);
 
            if(deviceExtension->simplexOnly) {
                break;
            }
        } else {
            // check if other channel(s) interrupted
            // must do nothing in simplex mode
            if((ULONG)CrNtInterlockedCompareExchange(CRNT_ILK_PTYPE &(chan->CheckIntr),
                                          CRNT_ILK_TYPE CHECK_INTR_ACTIVE,
                                          CRNT_ILK_TYPE CHECK_INTR_DETECTED) != CHECK_INTR_DETECTED) {
                continue;
            }
            //ASSERT(!deviceExtension->simplexOnly);
            chan->DpcState = DPC_STATE_ISR;
            if(!AtapiInterrupt__(HwDeviceExtension, (UCHAR)c)) {
                InterlockedExchange(&(chan->CheckIntr), CHECK_INTR_IDLE);
            }
        }
    }
    // In simplex mode next command must be sent to device here
    if(deviceExtension->simplexOnly && chan) {
        PSCSI_REQUEST_BLOCK srb;
        chan = UniataGetNextChannel(chan);
        if(chan) {
            srb = UniataGetCurRequest(chan);
        } else {
            srb = NULL;
        }
        if(srb) {
            AtapiStartIo__(HwDeviceExtension, srb, FALSE);
        }
    }
 
    return RETVAL_XXableInterrupts;
 
} // end AtapiEnableInterrupts__()

Referenced by AtapiCallBack__(), and AtapiInterrupt__().

AtapiHardReset()

VOID DDKFASTAPI AtapiHardReset	(	IN struct _HW_CHANNEL *	chan,
		IN BOOLEAN	DisableInterrupts,
		IN ULONG	Delay
	)

Definition at line 948 of file id_ata.cpp.

{
    KdPrint2((PRINT_PREFIX "AtapiHardReset: %d, dis=%d\n", Delay, DisableInterrupts));
    AtapiWritePort1(chan, IDX_IO2_o_Control, IDE_DC_RESET_CONTROLLER |
                              (DisableInterrupts ? IDE_DC_DISABLE_INTERRUPTS : 0));
    chan->last_devsel = -1;
    AtapiStallExecution(Delay);
    AtapiWritePort1(chan, IDX_IO2_o_Control, IDE_DC_REENABLE_CONTROLLER);
} // end AtapiHardReset()

Referenced by AtapiResetController__(), CheckDevice(), and FindDevices().

AtapiHwInitialize()

BOOLEAN NTAPI AtapiHwInitialize

(

IN PVOID

HwDeviceExtension

)

Definition at line 3342 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    ULONG                numberChannels  = deviceExtension->NumberChannels;
    ULONG c;
 
    KdPrint2((PRINT_PREFIX "AtapiHwInitialize: (base)\n"));
 
    if(WinVer_WDM_Model) {
        AtapiResetController__(HwDeviceExtension, CHAN_NOT_SPECIFIED, RESET_COMPLETE_ALL);
    }
    if(deviceExtension->MasterDev) {
        KdPrint2((PRINT_PREFIX "  mark chan %d of master controller [%x] as inited\n",
            deviceExtension->Channel, deviceExtension->DevIndex));
        BMList[deviceExtension->DevIndex].ChanInitOk |= 0x01 << deviceExtension->Channel;
    }
 
    /* do extra chipset specific setups */
    AtapiChipInit(HwDeviceExtension, DEVNUM_NOT_SPECIFIED, CHAN_NOT_SPECIFIED);
/*
    if(deviceExtension->Isr2DevObj && (deviceExtension->HwFlags & UNIATA_SATA)) {
        KdPrint2((PRINT_PREFIX " enable ISR2 to catch unexpected interrupts\n"));
        BMList[deviceExtension->DevIndex].Isr2Enable = TRUE;
    }
*/
    for (c = 0; c < numberChannels; c++) {
        AtapiHwInitialize__(deviceExtension, c);
    }
    KdPrint2((PRINT_PREFIX "AtapiHwInitialize: (base) done\n"));
    return TRUE;
} // end AtapiHwInitialize()

Referenced by DriverEntry().

AtapiHwInitialize__()

VOID NTAPI AtapiHwInitialize__	(	IN PHW_DEVICE_EXTENSION	deviceExtension,
		IN ULONG	lChannel
	)

Definition at line 3378 of file id_ata.cpp.

{
    ULONG i;
    UCHAR statusByte, errorByte;
    PHW_CHANNEL chan = &(deviceExtension->chan[lChannel]);
    PHW_LU_EXTENSION     LunExt;
//    ULONG tmp32;
    ULONG PreferedMode = 0xffffffff;
 
    if((deviceExtension->HwFlags & UNIATA_AHCI) &&
       !UniataAhciChanImplemented(deviceExtension, lChannel)) {
        return;
    }
 
    AtapiChipInit(deviceExtension, DEVNUM_NOT_SPECIFIED, lChannel);
    FindDevices(deviceExtension, 0, lChannel);
 
    for (i = 0; i < chan->NumberLuns; i++) {
 
        KdPrint3((PRINT_PREFIX "AtapiHwInitialize: lChannel %#x, dev %x\n", lChannel, i));
 
        LunExt = chan->lun[i];
        // skip empty slots
        if (!(LunExt->DeviceFlags & DFLAGS_DEVICE_PRESENT)) {
            continue;
        }
 
        AtapiDisableInterrupts(deviceExtension, lChannel);
        AtapiStallExecution(1);
 
        if (!(LunExt->DeviceFlags & (DFLAGS_ATAPI_DEVICE | DFLAGS_MANUAL_CHS))) {
 
            KdPrint2((PRINT_PREFIX "AtapiHwInitialize: IDE branch\n"));
            // Enable media status notification
            IdeMediaStatus(TRUE,deviceExtension,lChannel,(UCHAR)i);
 
            // If supported, setup Multi-block transfers.
            statusByte = AtaCommand(deviceExtension, i, lChannel,
                                IDE_COMMAND_SET_MULTIPLE, 0, 0, 0,
                                LunExt->MaximumBlockXfer, 0, ATA_WAIT_BASE_READY);
 
            // Check for errors. Reset the value to 0 (disable MultiBlock) if the
            // command was aborted.
            if (statusByte & IDE_STATUS_ERROR) {
 
                // Read the error register.
                errorByte = AtapiReadPort1(chan, IDX_IO1_i_Error);
 
                KdPrint2((PRINT_PREFIX "AtapiHwInitialize: Error setting multiple mode. Status %#x, error byte %#x\n",
                            statusByte,
                            errorByte));
 
                statusByte = AtaCommand(deviceExtension, i, lChannel,
                                    IDE_COMMAND_SET_MULTIPLE, 0, 0, 0,
                                    0, 0, ATA_WAIT_BASE_READY);
 
                if (statusByte & IDE_STATUS_ERROR) {
                    // Read the error register.
                    errorByte = AtapiReadPort1(chan, IDX_IO1_i_Error);
 
                    KdPrint2((PRINT_PREFIX "AtapiHwInitialize: Error disabling multiple mode. Status %#x, error byte %#x\n",
                                statusByte,
                                errorByte));
                }
                // Adjust the devExt. value, if necessary.
                LunExt->MaximumBlockXfer = 0;
 
            } else {
                KdPrint2((PRINT_PREFIX
                            "AtapiHwInitialize: Using Multiblock on Device %d. Blocks / int - %d\n",
                            i,
                            LunExt->MaximumBlockXfer));
            }
 
            if(LunExt->IdentifyData.MajorRevision) {
 
                if(LunExt->opt_ReadCacheEnable) {
                    KdPrint2((PRINT_PREFIX "  Try Enable Read Cache\n"));
                    // If supported, setup read/write cacheing
                    statusByte = AtaCommand(deviceExtension, i, lChannel,
                                        IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                        0, ATA_C_F_ENAB_RCACHE, ATA_WAIT_BASE_READY);
 
                    // Check for errors.
                    if (statusByte & IDE_STATUS_ERROR) {
                        KdPrint2((PRINT_PREFIX
                                    "AtapiHwInitialize: Enable read/write cacheing on Device %d failed\n",
                                    i));
                        LunExt->DeviceFlags &= ~DFLAGS_RCACHE_ENABLED;
                    } else {
                        LunExt->DeviceFlags |= DFLAGS_RCACHE_ENABLED;
                    }
                } else {
                    KdPrint2((PRINT_PREFIX "  Disable Read Cache\n"));
                    statusByte = AtaCommand(deviceExtension, i, lChannel,
                                        IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                        0, ATA_C_F_DIS_RCACHE, ATA_WAIT_BASE_READY);
                    LunExt->DeviceFlags &= ~DFLAGS_RCACHE_ENABLED;
                }
                if(LunExt->IdentifyData.FeaturesSupport.WriteCache) {
                    if(LunExt->opt_WriteCacheEnable) {
                        KdPrint2((PRINT_PREFIX "  Try Enable Write Cache\n"));
                        // If supported & allowed, setup write cacheing
                        statusByte = AtaCommand(deviceExtension, i, lChannel,
                                            IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                            0, ATA_C_F_ENAB_WCACHE, ATA_WAIT_BASE_READY);
                        // Check for errors.
                        if (statusByte & IDE_STATUS_ERROR) {
                            KdPrint2((PRINT_PREFIX
                                        "AtapiHwInitialize: Enable write cacheing on Device %d failed\n",
                                        i));
                            LunExt->DeviceFlags &= ~DFLAGS_WCACHE_ENABLED;
                        } else {
                            LunExt->DeviceFlags |= DFLAGS_WCACHE_ENABLED;
                        }
                    } else {
                        KdPrint2((PRINT_PREFIX "  Disable Write Cache\n"));
                        statusByte = AtaCommand(deviceExtension, i, lChannel,
                                            IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                            0, ATA_C_F_DIS_WCACHE, ATA_WAIT_BASE_READY);
                        LunExt->DeviceFlags &= ~DFLAGS_WCACHE_ENABLED;
                    }
                }
 
                if(/*LunExt->IdentifyData.FeaturesSupport.PowerMngt ||*/
                   LunExt->IdentifyData.FeaturesSupport.APM) {
 
                    if(LunExt->opt_AdvPowerMode) {
                        KdPrint2((PRINT_PREFIX "  Try Enable Adv. Power Mgmt\n"));
                        // setup APM
                        statusByte = AtaCommand(deviceExtension, i, lChannel,
                                            IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                            LunExt->opt_AdvPowerMode, ATA_C_F_ENAB_APM, ATA_WAIT_BASE_READY);
                        // Check for errors.
                        if (statusByte & IDE_STATUS_ERROR) {
                            KdPrint2((PRINT_PREFIX
                                        "AtapiHwInitialize: Enable APM on Device %d failed\n",
                                        i));
                        }
                    } else {
                        KdPrint2((PRINT_PREFIX "  Disable Adv. Power Mgmt\n"));
                        statusByte = AtaCommand(deviceExtension, i, lChannel,
                                            IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                            0, ATA_C_F_DIS_APM, ATA_WAIT_BASE_READY);
                    }
                }
                if(LunExt->IdentifyData.FeaturesSupport.AutoAcoustic) {
                    if(LunExt->opt_AcousticMode) {
                        KdPrint2((PRINT_PREFIX "  Try Enable Acoustic Mgmt\n"));
                        // setup acoustic mgmt
                        statusByte = AtaCommand(deviceExtension, i, lChannel,
                                            IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                            LunExt->opt_AcousticMode, ATA_C_F_ENAB_ACOUSTIC, ATA_WAIT_BASE_READY);
                        // Check for errors.
                        if (statusByte & IDE_STATUS_ERROR) {
                            KdPrint2((PRINT_PREFIX
                                        "AtapiHwInitialize: Enable Acoustic Mgmt on Device %d failed\n",
                                        i));
                        }
                    } else {
                        KdPrint2((PRINT_PREFIX "  Disable Acoustic Mgmt\n"));
                        statusByte = AtaCommand(deviceExtension, i, lChannel,
                                            IDE_COMMAND_SET_FEATURES, 0, 0, 0,
                                            0, ATA_C_F_DIS_ACOUSTIC, ATA_WAIT_BASE_READY);
                    }
                }
                if(LunExt->IdentifyData.FeaturesSupport.Standby) {
                    KdPrint2((PRINT_PREFIX "  Try init standby timer: %d\n"));
                    // setup standby timer
                    statusByte = AtaCommand(deviceExtension, i, lChannel,
                                        IDE_COMMAND_IDLE, 0, 0, 0,
                                        LunExt->opt_StandbyTimer, 0, ATA_WAIT_BASE_READY);
                    // Check for errors.
                    if (statusByte & IDE_STATUS_ERROR) {
                        KdPrint2((PRINT_PREFIX
                                    "AtapiHwInitialize: standby timer on Device %d failed\n",
                                    i));
                    }
                }
            }
 
        } else if (!(LunExt->DeviceFlags & DFLAGS_CHANGER_INITED)){
 
            ULONG j;
            //BOOLEAN isSanyo = FALSE;
            CCHAR vendorId[26];
 
            KdPrint2((PRINT_PREFIX "AtapiHwInitialize: ATAPI/Changer branch\n"));
 
            // Attempt to identify any special-case devices - psuedo-atapi changers, atapi changers, etc.
            for (j = 0; j < 26; j += 2) {
 
                // Build a buffer based on the identify data.
                MOV_DW_SWP(vendorId[j], ((PUCHAR)LunExt->IdentifyData.ModelNumber)[j]);
            }
 
            if (!AtapiStringCmp (vendorId, "CD-ROM  CDR", 11)) {
 
                // Inquiry string for older model had a '-', newer is '_'
                if (vendorId[12] == 'C') {
 
                    // Torisan changer. Set the bit. This will be used in several places
                    // acting like 1) a multi-lun device and 2) building the 'special' TUR's.
                    LunExt->DeviceFlags |= (DFLAGS_CHANGER_INITED | DFLAGS_SANYO_ATAPI_CHANGER);
                    LunExt->DiscsPresent = 3;
                    //isSanyo = TRUE;
                }
            }
        }
 
        PreferedMode = LunExt->opt_MaxTransferMode;
        if((PreferedMode == 0xffffffff) || (PreferedMode > chan->MaxTransferMode)) {
            KdPrint2((PRINT_PREFIX "MaxTransferMode (overriden): %#x\n", chan->MaxTransferMode));
            PreferedMode = chan->MaxTransferMode;
        }
 
        if(LunExt->opt_PreferedTransferMode != 0xffffffff) {
            KdPrint2((PRINT_PREFIX "PreferedTransferMode: %#x\n", PreferedMode));
            PreferedMode = min(LunExt->opt_PreferedTransferMode, PreferedMode);
        }
 
        KdPrint2((PRINT_PREFIX "  try mode %#x\n", PreferedMode));
        LunExt->LimitedTransferMode =
        LunExt->TransferMode =
            (CHAR)PreferedMode;
 
        AtapiDmaInit__(deviceExtension, LunExt);
 
        LunExt->LimitedTransferMode =
            LunExt->TransferMode;
        KdPrint2((PRINT_PREFIX "Using %#x mode\n", LunExt->TransferMode));
 
        // We need to get our device ready for action before
        // returning from this function
 
        // According to the atapi spec 2.5 or 2.6, an atapi device
        // clears its status BSY bit when it is ready for atapi commands.
        // However, some devices (Panasonic SQ-TC500N) are still
        // not ready even when the status BSY is clear.  They don't react
        // to atapi commands.
        //
        // Since there is really no other indication that tells us
        // the drive is really ready for action.  We are going to check BSY
        // is clear and then just wait for an arbitrary amount of time!
        //
        if (LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) {
            ULONG waitCount;
 
            // have to get out of the loop sometime!
            // 10000 * 100us = 1000,000us = 1000ms = 1s
            waitCount = 10000;
            GetStatus(chan, statusByte);
            if(statusByte == IDE_STATUS_WRONG) {
                waitCount = 0;
            }
            while ((statusByte & IDE_STATUS_BUSY) && waitCount) {
 
                KdPrint2((PRINT_PREFIX "Wait for ATAPI (status %x)\n", statusByte));
                // Wait for Busy to drop.
                AtapiStallExecution(100);
                GetStatus(chan, statusByte);
                waitCount--;
            }
 
            // 5000 * 100us = 500,000us = 500ms = 0.5s
            if(statusByte != IDE_STATUS_WRONG) {
                waitCount = 5000;
                do {
                    AtapiStallExecution(100);
                } while (waitCount--);
            }
        }
        GetBaseStatus(chan, statusByte);
        AtapiEnableInterrupts(deviceExtension, lChannel);
        AtapiStallExecution(10);
    }
 
    return;
 
} // end AtapiHwInitialize__()

Referenced by AtapiAdapterControl(), AtapiHwInitialize(), and AtapiResetController__().

AtapiHwInitializeChanger()

VOID NTAPI AtapiHwInitializeChanger	(	IN PVOID	HwDeviceExtension,
		IN PSCSI_REQUEST_BLOCK	Srb,
		IN PMECHANICAL_STATUS_INFORMATION_HEADER	MechanismStatus
	)

Definition at line 3667 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    ULONG lChannel = GET_CHANNEL(Srb);
    PHW_CHANNEL chan = &(deviceExtension->chan[lChannel]);
    ULONG DeviceNumber = GET_CDEV(Srb);
    PHW_LU_EXTENSION     LunExt = chan->lun[DeviceNumber];
 
    if (MechanismStatus) {
        LunExt->DiscsPresent = MechanismStatus->NumberAvailableSlots;
        if (LunExt->DiscsPresent > 1) {
            LunExt->DeviceFlags |= DFLAGS_ATAPI_CHANGER;
        }
    }
    return;
} // end AtapiHwInitializeChanger()

Referenced by AtapiInterrupt__().

AtapiInterrupt()

BOOLEAN NTAPI AtapiInterrupt

(

IN PVOID

HwDeviceExtension

)

Definition at line 4033 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    ULONG c, _c;
    BOOLEAN status = FALSE;
    ULONG c_state;
    ULONG i_res = 0;
    ULONG pass;
    //BOOLEAN checked[AHCI_MAX_PORT];
    ULONG hIS;
    ULONG checked;
 
    KdPrint2((PRINT_PREFIX "Intr: DeviceID+VendorID/Rev %#x/%#x (ex %d)\n",
        deviceExtension->DevID, deviceExtension->RevID, deviceExtension->ExpectingInterrupt ));
 
    if(deviceExtension->HwFlags & UNIATA_AHCI) {
        // AHCI may generate state change notification, never skip this check
        hIS = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_IS);
        KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): AHCI: hIS=%x cntrlr %#x chan %#x\n",hIS, deviceExtension->DevIndex, deviceExtension->Channel));
        if(!hIS) {
            return FALSE;
        }
        // assume all non-interrupted ports to be already checked
        checked = ~hIS;
        // assume all not implemented ports to be already checked
        checked |= ~deviceExtension->AHCI_PI;
    } else {
        checked = 0; // assume all ports are not checked
    }
 
    if(!deviceExtension->ExpectingInterrupt) {
        // if we do not expect interrupt, exit now,
        // but keep in mind that it can be unexpected one
        // Note: this is just a hint, not exact counter
        KdPrint2((PRINT_PREFIX "unexpected, 1st chance\n"));
        //deviceExtension->ExpectingInterrupt++;
        //return FALSE;
    }
    // clear this flag now, it can be set again in sub-calls
    deviceExtension->ExpectingInterrupt=0;
 
 
//    for(_c=0; _c<deviceExtension->NumberChannels; _c++) {
//        checked[_c] = (UCHAR)((hIS >> _c) & 0x01);
//    }
 
//    fc =
    for(pass=0; pass<2; pass++) {
        //KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): pass %d\n", pass));
        if(status && pass) {
            // we catched some expected interrupts now.
            // do not touch unexpected until next ISR call
            break;
        }
        for(_c=0; _c<deviceExtension->NumberChannels; _c++) {
 
            c = (_c+deviceExtension->FirstChannelToCheck) % deviceExtension->NumberChannels;
 
            if((checked>>c) & 0x01)
                continue;
 
            // check non-empty and expecting interrupt channels first
            if(!pass && !deviceExtension->chan[c].ExpectingInterrupt)
                continue;
 
            checked |= (ULONG)1 << c;
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): cntrlr %#x chan %#x\n",deviceExtension->DevIndex, c));
 
            if(CrNtInterlockedExchangeAdd(&(deviceExtension->chan[c].DisableIntr), 0)) {
                // we get here on idle channels or when ISR is posted to DPC
                KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): disabled INTR on ch %d\n", c));
                continue;
            }
            // lock channel. Wait, while 2nd ISR checks interrupt on this channel
            do {
                KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): try lock\n"));
                // c_state = deviceExtension->chan[c].CheckIntr;
                // if (deviceExtension->chan[c].CheckIntr == CHECK_INTR_DETECTED) {
                //     deviceExtension->chan[c].CheckIntr = CHECK_INTR_ACTIVE;
                // }
                c_state =
                    (ULONG)CrNtInterlockedCompareExchange(CRNT_ILK_PTYPE &(deviceExtension->chan[c].CheckIntr),
                                              CRNT_ILK_TYPE CHECK_INTR_ACTIVE,
                                              CRNT_ILK_TYPE CHECK_INTR_DETECTED);
                if(c_state == CHECK_INTR_IDLE) {
                    // c_state = deviceExtension->chan[c].CheckIntr;
                    // if (deviceExtension->chan[c].CheckIntr == CHECK_INTR_IDLE) {
                    //     deviceExtension->chan[c].CheckIntr = CHECK_INTR_ACTIVE
                    // }
                    c_state =
                        (ULONG)CrNtInterlockedCompareExchange(CRNT_ILK_PTYPE &(deviceExtension->chan[c].CheckIntr),
                                                  CRNT_ILK_TYPE CHECK_INTR_ACTIVE,
                                                  CRNT_ILK_TYPE CHECK_INTR_IDLE);
                }
            } while(c_state == CHECK_INTR_CHECK);
            KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): locked\n"));
            // check if already serviced
            if(c_state == CHECK_INTR_ACTIVE) {
                KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): CHECK_INTR_ACTIVE\n"));
                continue;
            }
 
            if((c_state == CHECK_INTR_DETECTED) ||
               (i_res = AtapiCheckInterrupt__(deviceExtension, (UCHAR)c))) {
 
                if(i_res == INTERRUPT_REASON_UNEXPECTED) {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): Catch unexpected\n"));
                    InterlockedExchange(&(deviceExtension->chan[c].CheckIntr), CHECK_INTR_IDLE);
                    //return TRUE;
                    status = TRUE;
                    continue;
                }
                // disable interrupts on other channel of legacy mode
                // ISA-bridged onboard controller
                if(deviceExtension->simplexOnly /*||
                   ((WinVer_Id() > WinVer_NT) && BMList[deviceExtension->DevIndex].MasterDev)*/) {
                    AtapiDisableInterrupts(deviceExtension, !c);
                }
 
                deviceExtension->chan[c].DpcState = DPC_STATE_ISR;
                if(AtapiInterrupt__(HwDeviceExtension, (UCHAR)c)) {
                    deviceExtension->LastInterruptedChannel = (UCHAR)c;
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): return status TRUE\n"));
                    status = TRUE;
                } else {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): set CHECK_INTR_IDLE\n"));
                    InterlockedExchange(&(deviceExtension->chan[c].CheckIntr), CHECK_INTR_IDLE);
                }
 
                // re-enable interrupts on other channel
                if(deviceExtension->simplexOnly /*||
                   ((WinVer_Id() > WinVer_NT) && BMList[deviceExtension->DevIndex].MasterDev)*/) {
                    AtapiEnableInterrupts(deviceExtension, !c);
                }
 
            } else {
                KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): set CHECK_INTR_IDLE (2)\n"));
                InterlockedExchange(&(deviceExtension->chan[c].CheckIntr), CHECK_INTR_IDLE);
            }
 
        }
    }
    KdPrint2((PRINT_PREFIX "AtapiInterrupt(base): exit with status %#x\n", status));
    if(status) {
        deviceExtension->FirstChannelToCheck++;
        if(deviceExtension->FirstChannelToCheck >= deviceExtension->NumberChannels)
            deviceExtension->FirstChannelToCheck = 0;
    }
    return status;
} // end AtapiInterrupt()

Referenced by DriverEntry().

AtapiInterrupt2()

BOOLEAN NTAPI AtapiInterrupt2	(	IN PKINTERRUPT	Interrupt,
		IN PVOID	Isr2HwDeviceExtension
	)

Definition at line 4192 of file id_ata.cpp.

{
    // This ISR is intended to catch interrupts when we are already in other ISR instance
    // for the same device. This may happen when we have multiple channels,
    // especially on SMP machines
 
    PISR2_DEVICE_EXTENSION Isr2DeviceExtension = (PISR2_DEVICE_EXTENSION)Isr2HwDeviceExtension;
    PHW_DEVICE_EXTENSION deviceExtension = Isr2DeviceExtension->HwDeviceExtension;
    ULONG c;
    BOOLEAN status = FALSE;
    ULONG c_count = 0;
    ULONG i_res;
    ULONG hIS;
    ULONG checked;
 
    // we should never get here for ISA/MCA
    if(!BMList[deviceExtension->DevIndex].Isr2Enable) {
        KdPrint2((PRINT_PREFIX "AtapiInterrupt2: NOT ACTIVE cntrlr %#x chan %#x\n",deviceExtension->DevIndex, deviceExtension->Channel));
        return FALSE;
    }
 
    if(deviceExtension->HwFlags & UNIATA_AHCI) {
        // AHCI may generate state change notification, never skip this check
        hIS = UniataAhciReadHostPort4(deviceExtension, IDX_AHCI_IS);
        KdPrint2((PRINT_PREFIX "AtapiInterrupt2: AHCI: hIS=%x cntrlr %#x chan %#x\n",hIS, deviceExtension->DevIndex, deviceExtension->Channel));
        if(!hIS) {
            return FALSE;
        }
        // assume all non-interrupted ports to be already checked
        checked = ~hIS;
        // assume all not implemented ports to be already checked
        checked |= ~deviceExtension->AHCI_PI;
 
    } else {
        checked = 0; // assume all ports are not checked
    }
    if(!deviceExtension->ExpectingInterrupt) {
        KdPrint2((PRINT_PREFIX "AtapiInterrupt2: !deviceExtension->ExpectingInterrupt\n"));
        deviceExtension->ExpectingInterrupt++;
        return FALSE;
    }
    //deviceExtension->ExpectingInterrupt = 0;
 
    for(c=0; c<deviceExtension->NumberChannels; c++) {
        KdPrint2((PRINT_PREFIX "AtapiInterrupt2: cntrlr %#x chan %#x\n",deviceExtension->DevIndex, c));
 
        if((checked>>c) & 0x01)
            continue;
 
        checked |= (ULONG)1 << c;
 
        if(CrNtInterlockedExchangeAdd(&(deviceExtension->chan[c].DisableIntr), 0)) {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt2: disabled INTR\n"));
            continue;
        }
 
        if((ULONG)CrNtInterlockedCompareExchange(CRNT_ILK_PTYPE &(deviceExtension->chan[c].CheckIntr),
                                      CRNT_ILK_TYPE CHECK_INTR_CHECK,
                                      CRNT_ILK_TYPE CHECK_INTR_IDLE) != CHECK_INTR_IDLE)
        {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt2: !CHECK_INTR_IDLE\n"));
            // hunt on unexpected intr (Some devices generate double interrupts,
            // some controllers (at least CMD649) interrupt twice with small delay.
            // If interrupts are disabled, they queue interrupt and re-issue it later,
            // when we do not expect it.
            continue;
        }
 
        c_count++;
        if((i_res = AtapiCheckInterrupt__(deviceExtension, (UCHAR)c))) {
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt2: intr\n"));
            if(i_res == INTERRUPT_REASON_UNEXPECTED) {
                KdPrint2((PRINT_PREFIX "AtapiInterrupt2: Catch unexpected\n"));
                InterlockedExchange(&(deviceExtension->chan[c].CheckIntr), CHECK_INTR_IDLE);
                return TRUE;
            }
 
            status = TRUE;
            InterlockedExchange(&(deviceExtension->chan[c].CheckIntr), CHECK_INTR_DETECTED);
        } else {
            InterlockedExchange(&(deviceExtension->chan[c].CheckIntr), CHECK_INTR_IDLE);
        }
    }
    KdPrint2((PRINT_PREFIX "AtapiInterrupt2: status %d, c_count %d\n", status, c_count));
    if(status && (c_count != deviceExtension->NumberChannels)) {
        // there is an active ISR/DPC for one channel, but
        // we have an interrupt from another one
        // Lets inform current ISR/DPC about new interrupt
        InterlockedExchange(&(deviceExtension->ReCheckIntr), CHECK_INTR_DETECTED);
    } else {
        status = FALSE;
    }
    KdPrint2((PRINT_PREFIX "AtapiInterrupt2: return %d\n", status));
    return status;
 
} // end AtapiInterrupt2()

Referenced by UniataConnectIntr2().

AtapiInterrupt__()

BOOLEAN NTAPI AtapiInterrupt__	(	IN PVOID	HwDeviceExtension,
		IN UCHAR	c
	)

atapiDev &&

deviceExtension->DWordIO

Definition at line 4981 of file id_ata.cpp.

{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PHW_CHANNEL chan = &(deviceExtension->chan[c]);
    // Get current Srb
    PSCSI_REQUEST_BLOCK srb = UniataGetCurRequest(chan);
    PATA_REQ AtaReq = srb ? (PATA_REQ)(srb->SrbExtension) : NULL;
 
    ULONG wordCount = 0, wordsThisInterrupt = DEV_BSIZE/2;
    ULONG status = SRB_STATUS_SUCCESS;
    UCHAR dma_status = 0;
    ULONG i;
    ULONG k;
    UCHAR statusByte = 0,interruptReason;
 
    BOOLEAN atapiDev = FALSE;
 
#ifdef _DEBUG
    UCHAR Channel;
#endif //_DEBUG
    UCHAR lChannel;
    UCHAR DeviceNumber;
    BOOLEAN DmaTransfer = FALSE;
    UCHAR error = 0;
    ULONG TimerValue = 1000;
    ULONG TotalTimerValue = 0;
#ifdef UNIATA_USE_XXableInterrupts
    BOOLEAN InDpc = (KeGetCurrentIrql() == DISPATCH_LEVEL);
#else
    BOOLEAN InDpc = (chan->DpcState != DPC_STATE_ISR);
#endif // UNIATA_USE_XXableInterrupts
    BOOLEAN UseDpc = deviceExtension->UseDpc;
//    BOOLEAN RestoreUseDpc = FALSE;
    BOOLEAN DataOverrun = FALSE;
    BOOLEAN NoStartIo = TRUE;
    BOOLEAN NoRetry = FALSE;
 
    KdPrint2((PRINT_PREFIX "AtapiInterrupt:\n"));
    if(InDpc) {
        KdPrint2((PRINT_PREFIX "  InDpc = TRUE\n"));
        //ASSERT((chan->ChannelCtrlFlags & CTRFLAGS_INTR_DISABLED));
    }
 
    UCHAR PathId;
    UCHAR TargetId;
    UCHAR Lun;
    UCHAR OldReqState = REQ_STATE_NONE;
    //ULONG ldev;
    PHW_LU_EXTENSION LunExt;
 
    lChannel = c;
 
#ifdef _DEBUG
    Channel = (UCHAR)(deviceExtension->Channel + lChannel);
 
    KdPrint2((PRINT_PREFIX "  cntrlr %#x:%d, irql %#x, c %d\n", deviceExtension->DevIndex, Channel, KeGetCurrentIrql(), c));
#endif //_DEBUG
 
    if((chan->ChannelCtrlFlags & CTRFLAGS_DMA_ACTIVE) ||
       (AtaReq && (AtaReq->Flags & REQ_FLAG_DMA_OPERATION)) ||
       (deviceExtension->HwFlags & UNIATA_AHCI)) {
        DmaTransfer = TRUE;
        KdPrint2((PRINT_PREFIX "  DmaTransfer = TRUE\n"));
    }
 
    if (srb) {
        PathId   = srb->PathId;
        TargetId = srb->TargetId;
        Lun      = srb->Lun;
    } else {
        PathId = (UCHAR)c;
        TargetId =
        Lun      = 0;
        goto enqueue_next_req;
    }
 
    //ldev = GET_LDEV2(PathId, TargetId, Lun);
    DeviceNumber = (UCHAR)(TargetId);
    LunExt = chan->lun[DeviceNumber];
    atapiDev = (LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) ? TRUE : FALSE;
    KdPrint2((PRINT_PREFIX "  dev_type %s\n", atapiDev ? "ATAPI" : "IDE"));
 
    // check if we are in ISR DPC
    if(InDpc) {
        KdPrint2((PRINT_PREFIX "  InDpc -> CTRFLAGS_INTR_DISABLED\n"));
        goto ServiceInterrupt;
    }
 
    if (DmaTransfer) {
        dma_status = GetDmaStatus(deviceExtension, lChannel);
    }
 
    if (!(chan->ExpectingInterrupt)) {
 
        KdPrint2((PRINT_PREFIX "  Unexpected interrupt for this channel.\n"));
        return FALSE;
    }
 
    // change request state
    if(AtaReq) {
        OldReqState = AtaReq->ReqState;
        AtaReq->ReqState = REQ_STATE_PROCESSING_INTR;
        KdPrint2((PRINT_PREFIX "  OldReqState = %x\n", OldReqState));
    }
 
    // We don't want using DPC for fast operations, like
    // DMA completion, sending CDB, short ATAPI transfers, etc.
    // !!!! BUT !!!!
    // We MUST use DPC, because of interprocessor synchronization
    // on multiprocessor platforms
 
    if(DmaTransfer)
        goto ServiceInterrupt;
 
    switch(OldReqState) {
    case REQ_STATE_ATAPI_EXPECTING_CMD_INTR:
        KdPrint3((PRINT_PREFIX "  EXPECTING_CMD_INTR\n"));
    case REQ_STATE_ATAPI_EXPECTING_DATA_INTR:
    case REQ_STATE_ATAPI_EXPECTING_DATA_INTR2:
    case REQ_STATE_DPC_WAIT_BUSY0:
    case REQ_STATE_DPC_WAIT_BUSY1:
        KdPrint2((PRINT_PREFIX "  continue service interrupt\n"));
        goto ServiceInterrupt;
    case REQ_STATE_ATAPI_DO_NOTHING_INTR:
        KdPrint2((PRINT_PREFIX "  do nothing on interrupt\n"));
        return TRUE;
    }
 
    if((!DmaTransfer && !atapiDev) || deviceExtension->DriverMustPoll) {
        KdPrint2((PRINT_PREFIX "  service PIO HDD\n"));
        UseDpc = FALSE;
    }
 
#ifndef UNIATA_CORE
 
    if(!UseDpc)
        goto ServiceInterrupt;
 
#ifdef UNIATA_USE_XXableInterrupts
    if(InDpc) {
        KdPrint2((PRINT_PREFIX "  Unexpected InDpc\n"));
        ASSERT(FALSE);
        // shall never get here
        TimerValue = 1;
        goto CallTimerDpc;
    }
 
    KdPrint2((PRINT_PREFIX "  this is direct DPC call on DRQL\n"));
    if(AtaReq) {
        AtaReq->ReqState = REQ_STATE_DPC_INTR_REQ;
        KdPrint2((PRINT_PREFIX "  ReqState -> REQ_STATE_DPC_INTR_REQ\n"));
    } else {
        KdPrint2((PRINT_PREFIX "  DPC without AtaReq!!!\n"));
    }
#else
    KdPrint2((PRINT_PREFIX "call service interrupt\n"));
    goto ServiceInterrupt;
#endif // UNIATA_USE_XXableInterrupts
 
PostToDpc:
 
    // Attention !!!
    // AtapiInterruptDpc() is called on DISPATCH_LEVEL
    // We always get here when are called from timer callback, which is invoked on DRQL.
    // It is intended to lower IRQL and let other interrupts to be serviced while we are waiting for BUSY release
 
    KdPrint2((PRINT_PREFIX "AtapiInterrupt: start DPC init...\n"));
    // disable interrupts for this channel,
    // but avoid recursion and double-disable
    if(OldReqState != REQ_STATE_DPC_WAIT_BUSY1) {
        UniataExpectChannelInterrupt(chan, FALSE);
        AtapiDisableInterrupts(deviceExtension, lChannel);
    }
    // go to ISR DPC
    chan->ChannelCtrlFlags |= CTRFLAGS_DPC_REQ;
 
#ifdef UNIATA_USE_XXableInterrupts
    // Will lower IRQL to DISPATCH_LEVEL
    ScsiPortNotification(CallEnableInterrupts, HwDeviceExtension,
                         /*c ?*/ AtapiInterruptDpc/*_1 : AtapiInterruptDpc_0*/);
    KdPrint2((PRINT_PREFIX "AtapiInterrupt: DPC inited\n"));
#else
    // Will raise IRQL to DIRQL
    AtapiQueueTimerDpc(HwDeviceExtension, c,
                         AtapiInterruptDpc,
                         TimerValue);
    KdPrint2((PRINT_PREFIX "AtapiInterrupt: Timer DPC inited\n"));
#endif // UNIATA_USE_XXableInterrupts
    return TRUE;
 
#ifndef UNIATA_CORE
CallTimerDpc:
    AtaReq->ReqState = REQ_STATE_PROCESSING_INTR;
CallTimerDpc2:
    if(!InDpc && OldReqState != REQ_STATE_DPC_WAIT_BUSY1) {
        // we must block interrupts from this channel
        // If device generate new interrupt before we get to DPC,
        // ISR will assume, that it is NOT our interrupt
        AtapiDisableInterrupts(deviceExtension, lChannel);
        // We should not clean ExpectingInterrupt flag on channel, since it is used in DPC
    }
    // Will raise IRQL to DIRQL
    AtapiQueueTimerDpc(HwDeviceExtension, c,
                         AtapiCallBack_X,
                         TimerValue);
    return TRUE;
#endif //UNIATA_CORE
 
ServiceInterrupt:
 
    if(AtaReq && InDpc) {
        switch(AtaReq->ReqState) {
        case REQ_STATE_DPC_WAIT_DRQ0:
            goto PIO_wait_DRQ0;
        case REQ_STATE_DPC_WAIT_BUSY:
            goto PIO_wait_busy;
        case REQ_STATE_DPC_WAIT_DRQ:
            goto PIO_wait_DRQ;
        case REQ_STATE_DPC_WAIT_DRQ_ERR:
            goto continue_err;
        case REQ_STATE_DPC_WAIT_BUSY0:
        case REQ_STATE_DPC_WAIT_BUSY1:
            // continue normal execution
            break;
        }
    }
#else
ServiceInterrupt:
#endif //UNIATA_CORE
/*
    // make additional delay for old devices (if we are not in DPC)
    if((!LunExt->IdentifyData.MajorRevision || (deviceExtension->lun[DeviceNumber].TransferMode < ATA_PIO4))
             &&
       !InDpc &&
       !atapiDev &&
       !(deviceExtension->HwFlags & UNIATA_SATA)
       ) {
        KdPrint2((PRINT_PREFIX "  additional delay 10us for old devices\n"));
        AtapiStallExecution(10);
    }
*/
 
    /* clear interrupt and get status */
    if(deviceExtension->HwFlags & UNIATA_AHCI) {
        UniataAhciEndTransaction(HwDeviceExtension, lChannel, DeviceNumber, srb);
        statusByte = (UCHAR)(AtaReq->ahci.in_status & IDE_STATUS_MASK);
 
        if(chan->AhciLastIS & ~(ATA_AHCI_P_IX_DHR | ATA_AHCI_P_IX_PS | ATA_AHCI_P_IX_DS | ATA_AHCI_P_IX_SDB)) {
            KdPrint3((PRINT_PREFIX "Err intr (%#x), SE (%#x)\n",
                chan->AhciLastIS & ~(ATA_AHCI_P_IX_DHR | ATA_AHCI_P_IX_PS | ATA_AHCI_P_IX_DS | ATA_AHCI_P_IX_SDB),
                chan->AhciLastSError));
            if(chan->AhciLastIS & ~ATA_AHCI_P_IX_OF) {
 
                if((chan->AhciLastIS == ATA_AHCI_P_IX_INF) &&
                   !(statusByte & IDE_STATUS_ERROR) &&
                   !chan->AhciLastSError &&
                   srb && (srb->SrbFlags & SRB_FLAGS_DATA_IN)
                   ) {
                  KdPrint3((PRINT_PREFIX "ATA_AHCI_P_IX_INF on READ, assume underflow\n"));
                  // continue processing in regular way
                } else {
 
                  //KdPrint3((PRINT_PREFIX "Err mask (%#x)\n", chan->AhciLastIS & ~ATA_AHCI_P_IX_OF));
                  // We have some other error except Overflow
                  // Just signal ERROR, operation will be aborted in ERROR branch.
                  statusByte |= IDE_STATUS_ERROR;
                  AtaReq->ahci.in_serror = chan->AhciLastSError;
                  if(chan->AhciLastSError & (ATA_SE_HANDSHAKE_ERR | ATA_SE_LINKSEQ_ERR | ATA_SE_TRANSPORT_ERR | ATA_SE_UNKNOWN_FIS)) {
                      KdPrint2((PRINT_PREFIX "Unrecoverable\n"));
                      NoRetry = TRUE;
                  }
                }
            } else {
                // We have only Overflow. Abort operation and continue
#ifdef _DEBUG
                UniataDumpAhciPortRegs(chan);
#endif
                if(!UniataAhciAbortOperation(chan)) {
                    KdPrint2((PRINT_PREFIX "need UniataAhciReset\n"));
                }
#ifdef _DEBUG
                UniataDumpAhciPortRegs(chan);
#endif
                UniataAhciWaitCommandReady(chan, 10);
            }
        }
 
    } else {
        GetBaseStatus(chan, statusByte);
    }
    if(atapiDev) {
        KdPrint3((PRINT_PREFIX "AtapiInterrupt: ATAPI Entered with status (%#x)\n", statusByte));
    } else {
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: Entered with status (%#x)\n", statusByte));
    }
 
    if(!UseDpc) {
        KdPrint2((PRINT_PREFIX "  operate like in DPC\n"));
        InDpc = TRUE;
    }
 
    if (!atapiDev) {
        // IDE
        if(deviceExtension->HwFlags & UNIATA_AHCI) {
            KdPrint3((PRINT_PREFIX "  AHCI branch (IDE)\n"));
        } else
        if (statusByte & IDE_STATUS_BUSY) {
            if (deviceExtension->DriverMustPoll) {
                // Crashdump is polling and we got caught with busy asserted.
                // Just go away, and we will be polled again shortly.
                KdPrint2((PRINT_PREFIX "  Hit BUSY while polling during crashdump.\n"));
                goto ReturnEnableIntr;
            }
try_dpc_wait:
            // Ensure BUSY is non-asserted.
            // make a very small idle before falling to DPC
            k = (InDpc && UseDpc) ? 1000 : 2;
 
            for (i = 0; i < k; i++) {
 
                GetBaseStatus(chan, statusByte);
                if (!(statusByte & IDE_STATUS_BUSY)) {
                    break;
                }
                AtapiStallExecution(10);
            }
 
            if (!InDpc && UseDpc && i == 2) {
 
                KdPrint2((PRINT_PREFIX "  BUSY on entry. Status %#x, Base IO %#x\n", statusByte));
 
                TimerValue = 50;
                AtaReq->ReqState = REQ_STATE_DPC_WAIT_BUSY0;
 
#ifndef UNIATA_CORE
                goto PostToDpc;
#else //UNIATA_CORE
                AtapiStallExecution(TimerValue);
                goto ServiceInterrupt;
#endif //UNIATA_CORE
            } else
            if (InDpc && i == k) {
                // reset the controller.
                KdPrint2((PRINT_PREFIX
                            "  Resetting due to BUSY on entry - %#x.\n",
                            statusByte));
                goto IntrPrepareResetController;
            }
        }
    } else {
        // ATAPI
        if(!LunExt->IdentifyData.MajorRevision &&
            InDpc &&
            !(deviceExtension->HwFlags & UNIATA_SATA)
            ) {
            //KdPrint2((PRINT_PREFIX "  additional delay 10us for old devices (2)\n"));
            //AtapiStallExecution(10);
        }
        if(deviceExtension->HwFlags & UNIATA_AHCI) {
            KdPrint3((PRINT_PREFIX "  AHCI branch (ATAPI)\n"));
        } else {
            interruptReason = (AtapiReadPort1(chan, IDX_ATAPI_IO1_i_InterruptReason) & ATAPI_IR_Mask);
            KdPrint3((PRINT_PREFIX "AtapiInterrupt: iReason %x\n", interruptReason));
        }
 
        if (statusByte & IDE_STATUS_BUSY) {
        //if(chan->ChannelCtrlFlags & CTRFLAGS_DSC_BSY) {}
/*
#ifndef UNIATA_CORE
            // This is just workaround
            // We should DISABLE interrupts before entering WAIT state
            UniataExpectChannelInterrupt(chan, TRUE);
#endif //UNIATA_CORE
*/
            KdPrint3((PRINT_PREFIX "  BUSY on ATAPI device, waiting %d us\n", LunExt->AtapiReadyWaitDelay));
#ifndef UNIATA_CORE
            if(LunExt->AtapiReadyWaitDelay && (LunExt->AtapiReadyWaitDelay > g_opt_MaxIsrWait) && !InDpc && UseDpc) {
                TimerValue = LunExt->AtapiReadyWaitDelay;
                KdPrint2((PRINT_PREFIX "  too long wait: ISR -> DPC (0)\n"));
                AtaReq->ReqState = REQ_STATE_DPC_WAIT_BUSY0;
                goto CallTimerDpc2;
            }
#endif //UNIATA_CORE
            TimerValue = 10;
            for(k=20; k; k--) {
                GetBaseStatus(chan, statusByte);
                KdPrint3((PRINT_PREFIX "  status re-check %#x\n", statusByte));
                KdPrint3((PRINT_PREFIX "  Error reg (%#x)\n",
                            AtapiReadPort1(chan, IDX_ATAPI_IO1_i_Error)));
                if (!(statusByte & IDE_STATUS_BUSY)) {
                    KdPrint2((PRINT_PREFIX "  expecting intr + cleared BUSY\n"));
                    break;
                }
                TotalTimerValue += TimerValue;
                if(k <= 1) {
                    KdPrint3((PRINT_PREFIX "  too long wait -> DPC\n"));
                    if(!InDpc) {
                        KdPrint2((PRINT_PREFIX "  too long wait: ISR -> DPC\n"));
                        TimerValue = 100;
                        AtaReq->ReqState = REQ_STATE_DPC_WAIT_BUSY0;
                    } else {
                        KdPrint2((PRINT_PREFIX "  too long wait: DPC -> DPC\n"));
                        TimerValue = 1000;
                        AtaReq->ReqState = REQ_STATE_DPC_WAIT_BUSY1;
                    }
#ifndef UNIATA_CORE
                    if(UseDpc) {
                        if(!LunExt->AtapiReadyWaitDelay) {
                            LunExt->AtapiReadyWaitDelay = TotalTimerValue*2/3;
                        }
                        goto CallTimerDpc2;
                    }
#endif //UNIATA_CORE
                }
 
                AtapiStallExecution(TimerValue);
                TimerValue += 10;
            }
            if(!LunExt->AtapiReadyWaitDelay) {
                LunExt->AtapiReadyWaitDelay = TotalTimerValue*2/3;
                KdPrint2((PRINT_PREFIX "  store AtapiReadyWaitDelay: %d\n", LunExt->AtapiReadyWaitDelay));
            }
            if (statusByte & IDE_STATUS_BUSY) {
                KdPrint3((PRINT_PREFIX "  expecting intr + BUSY (2), try DPC wait\n"));
                goto try_dpc_wait;
            }
        }
    }
 
    if(AtaReq && DmaTransfer && !(deviceExtension->HwFlags & UNIATA_AHCI)) {
        switch(OldReqState) {
        case REQ_STATE_EARLY_INTR:
        case REQ_STATE_DPC_WAIT_BUSY0:
 
            if(chan->ChannelCtrlFlags & CTRFLAGS_DMA_ACTIVE) {
                KdPrint2((PRINT_PREFIX "AtapiInterrupt: DMA still active\n"));
                dma_status = AtapiDmaDone(HwDeviceExtension, DEVNUM_NOT_SPECIFIED, lChannel, NULL/*srb*/);
            }
            break;
        }
    }
 
//retry_check:
    // Check for error conditions.
    if ((statusByte & IDE_STATUS_ERROR) ||
        (dma_status & BM_STATUS_ERR)) {
 
        if(deviceExtension->HwFlags & UNIATA_AHCI) {
            error = AtaReq->ahci.in_error;
            // wait ready
#ifdef _DEBUG
            UniataDumpAhciPortRegs(chan);
#endif
            if(!UniataAhciAbortOperation(chan)) {
                KdPrint2((PRINT_PREFIX "need UniataAhciReset\n"));
            }
            // clear interrupts again
            UniataAhciWaitCommandReady(chan, 10);
#ifdef _DEBUG
            UniataDumpAhciPortRegs(chan);
#endif
            UniataAhciStatus(HwDeviceExtension, lChannel, DEVNUM_NOT_SPECIFIED);
            if(NoRetry) {
                AtaReq->retry += MAX_RETRIES;
                if(!error && (statusByte & IDE_STATUS_ERROR)) {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: force error status\n"));
                    error |= IDE_STATUS_ERROR;
                }
            }
#ifdef _DEBUG
            UniataDumpAhciPortRegs(chan);
#endif
        } else {
            error = AtapiReadPort1(chan, IDX_IO1_i_Error);
        }
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: Error %#x\n", error));
/*
        if(error & IDE_STATUS_CORRECTED_ERROR) {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: (corrected)\n"));
            statusByte &= ~IDE_STATUS_ERROR;
            goto retry_check;
        }
*/
        if(AtaReq) {
            KdPrint2((PRINT_PREFIX "  Bad Lba %#I64x\n", AtaReq->lba));
        } else {
            KdPrint2((PRINT_PREFIX "  Bad Lba unknown\n"));
        }
 
        if(deviceExtension->HwFlags & UNIATA_AHCI) {
            KdPrint2((PRINT_PREFIX "  no wait ready after error\n"));
        } else
        if(!atapiDev) {
            KdPrint2((PRINT_PREFIX "  wait 100 ready after IDE error\n"));
            AtapiStallExecution(100);
        } else {
            KdPrint2((PRINT_PREFIX "  wait 10 ready after ATAPI error\n"));
            AtapiStallExecution(10);
        }
continue_err:
 
        KdPrint3((PRINT_PREFIX "  Intr on DRQ %x\n",
            LunExt->DeviceFlags & DFLAGS_INT_DRQ));
 
        for (k = atapiDev ? 0 : 200; k; k--) {
            GetBaseStatus(chan, statusByte);
            if (!(statusByte & IDE_STATUS_DRQ)) {
                AtapiStallExecution(50);
            } else {
                break;
            }
        }
 
        if (!atapiDev) {
            /* if this is a UDMA CRC error, reinject request */
 
            AtaReq->retry++;
            if(AtaReq->retry < MAX_RETRIES) {
#ifdef IO_STATISTICS
                chan->lun[DeviceNumber]->ModeErrorCount[AtaReq->retry]++;
#endif //IO_STATISTICS
                if(DmaTransfer /*&&
                   (error & IDE_ERROR_ICRC)*/) {
                    KdPrint2((PRINT_PREFIX "Errors in DMA mode\n"));
                    if(AtaReq->retry < MAX_RETRIES) {
//fallback_pio:
                        if(!(deviceExtension->HwFlags & UNIATA_AHCI)) {
                            //AtaReq->Flags &= ~REQ_FLAG_DMA_OPERATION;
                            // Downrate will happen in AtapiDmaReinit(), try UDMA-2 for HDD only
                            AtaReq->Flags |= REQ_FLAG_FORCE_DOWNRATE;
                        }
                        AtaReq->ReqState = REQ_STATE_QUEUED;
                        goto reenqueue_req;
                    }
                } else {
                    if(!(AtaReq->Flags & REQ_FLAG_FORCE_DOWNRATE)) {
                        AtaReq->retry++;
                    }
                    KdPrint2((PRINT_PREFIX "Errors in PIO mode\n"));
                }
            }
        } else {
            interruptReason = (AtapiReadPort1(chan, IDX_ATAPI_IO1_i_InterruptReason) & ATAPI_IR_Mask);
            KdPrint3((PRINT_PREFIX "AtapiInterrupt: ATAPI Error, int reason %x\n", interruptReason));
 
            if(UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
                if(deviceExtension->HwFlags & UNIATA_AHCI) {
                    // Do nothing here
                } else
                if(deviceExtension->HwFlags & UNIATA_SATA) {
                    UniataSataClearErr(HwDeviceExtension, lChannel, UNIATA_SATA_IGNORE_CONNECT, 0);
                }
            }
 
            if(DmaTransfer && (chan->lun[DeviceNumber]->TransferMode > ATA_UDMA2) &&
               ((error >> 4) == SCSI_SENSE_HARDWARE_ERROR)) {
                if(AtaReq->retry < MAX_RETRIES) {
//fallback_pio:
                    // Downrate will happen in AtapiDmaReinit(), use PIO immediately for ATAPI
                    AtaReq->Flags &= ~REQ_FLAG_DMA_OPERATION;
                    AtaReq->Flags |= REQ_FLAG_FORCE_DOWNRATE;
//                        LunExt->DeviceFlags |= DFLAGS_FORCE_DOWNRATE;
                    AtaReq->ReqState = REQ_STATE_QUEUED;
                    goto reenqueue_req;
                }
            } else {
                if(!(AtaReq->Flags & REQ_FLAG_FORCE_DOWNRATE)) {
                    AtaReq->retry++;
                }
                KdPrint3((PRINT_PREFIX "Errors in PIO mode\n"));
            }
        }
 
        KdPrint3((PRINT_PREFIX "AtapiInterrupt: Error\n"));
        if (srb->Cdb[0] != SCSIOP_REQUEST_SENSE) {
            // Fail this request.
            status = SRB_STATUS_ERROR;
            goto CompleteRequest;
        } else {
            KdPrint2((PRINT_PREFIX "  continue with SCSIOP_REQUEST_SENSE\n"));
        }
    } else
    if(AtaReq->Flags & REQ_FLAG_FORCE_DOWNRATE_LBA48) {
        KdPrint2((PRINT_PREFIX "DMA doesn't work right with LBA48\n"));
        deviceExtension->HbaCtrlFlags |= HBAFLAGS_DMA_DISABLED_LBA48;
    } else
    if(AtaReq->Flags & REQ_FLAG_FORCE_DOWNRATE) {
#ifdef IO_STATISTICS
        KdPrint2((PRINT_PREFIX "Some higher mode doesn't work right :((\n"));
        KdPrint2((PRINT_PREFIX "Recovery stats[%d]: %d vs %d\n",
              AtaReq->retry,
              LunExt->RecoverCount[AtaReq->retry],
              LunExt->BlockIoCount
              ));
        LunExt->RecoverCount[AtaReq->retry]++;
        if(LunExt->RecoverCount[AtaReq->retry] >= LunExt->BlockIoCount/3 ||
           (deviceExtension->HwFlags & UNIATA_NO80CHK)
           ) {
#else
        if(deviceExtension->HwFlags & UNIATA_NO80CHK) {
#endif //IO_STATISTICS
            KdPrint2((PRINT_PREFIX "Limit transfer rate to %x\n", LunExt->TransferMode));
            LunExt->LimitedTransferMode =
                LunExt->TransferMode;
        }
    }
#ifdef IO_STATISTICS
    if(AtaReq->bcount) {
        // we need stats for Read/Write operations
        LunExt->BlockIoCount++;
    }
    LunExt->IoCount++;
#endif //IO_STATISTICS
 
continue_PIO:
 
    // check reason for this interrupt.
    if (atapiDev) {
 
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: ATAPI branch\n"));
        // ATAPI branch
 
        interruptReason = (AtapiReadPort1(chan, IDX_ATAPI_IO1_i_InterruptReason) & ATAPI_IR_Mask);
        KdPrint3((PRINT_PREFIX "AtapiInterrupt: iReason %x\n", interruptReason));
        if(DmaTransfer) {
            wordsThisInterrupt = DEV_BSIZE/2*512;
        } else {
            wordsThisInterrupt = DEV_BSIZE/2;
        }
 
    } else {
 
        // ATA branch
 
        if(DmaTransfer) {
            // simulate DRQ for DMA transfers
            statusByte |= IDE_STATUS_DRQ;
        }
        if (statusByte & IDE_STATUS_DRQ) {
 
            if(DmaTransfer) {
                wordsThisInterrupt = DEV_BSIZE/2*512;
            } else
            if (LunExt->MaximumBlockXfer) {
                wordsThisInterrupt = DEV_BSIZE/2 * LunExt->MaximumBlockXfer;
            }
 
            if (srb->SrbFlags & SRB_FLAGS_DATA_IN) {
 
                interruptReason = ATAPI_IR_IO_toHost;
 
            } else if (srb->SrbFlags & SRB_FLAGS_DATA_OUT) {
                interruptReason = ATAPI_IR_IO_toDev;
 
            } else {
                status = SRB_STATUS_ERROR;
                goto CompleteRequest;
            }
 
        } else if (statusByte & IDE_STATUS_BUSY) {
 
            //AtapiEnableInterrupts(deviceExtension, lChannel);
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: return FALSE on ATA IDE_STATUS_BUSY\n"));
            return FALSE;
 
        } else {
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: !DRQ, !BUSY, WordsLeft %#x\n", AtaReq->WordsLeft));
            if (AtaReq->WordsLeft) {
 
                // Funky behaviour seen with PCI IDE (not all, just one).
PIO_wait_DRQ0:
                // The ISR hits with DRQ low, but comes up later.
                for (k = 0; k < 5000; k++) {
                    GetBaseStatus(chan, statusByte);
                    if (statusByte & IDE_STATUS_DRQ) {
                        break;
                    }
                    if(!InDpc) {
                        // goto DPC
                        AtaReq->ReqState = REQ_STATE_DPC_WAIT_DRQ0;
                        TimerValue = 100;
                        KdPrint2((PRINT_PREFIX "AtapiInterrupt: go to DPC (drq0)\n"));
#ifndef UNIATA_CORE
                        goto PostToDpc;
#else //UNIATA_CORE
                        AtapiStallExecution(TimerValue);
                        goto ServiceInterrupt;
#endif //UNIATA_CORE
                    }
                    AtapiStallExecution(100);
                }
                if (k == 5000) {
                    // reset the controller.
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: Resetting due to DRQ not up. Status %#x\n",
                                statusByte));
IntrPrepareResetController:
                    AtapiResetController__(HwDeviceExtension, lChannel, RESET_COMPLETE_CURRENT);
                    goto ReturnEnableIntr;
 
                } else {
                    interruptReason = (srb->SrbFlags & SRB_FLAGS_DATA_IN) ? ATAPI_IR_IO_toHost : ATAPI_IR_IO_toDev;
                }
 
            } else {
                // Command complete - verify, write, or the SMART enable/disable.
                // Also get_media_status
                interruptReason = ATAPI_IR_IO_toHost | ATAPI_IR_COD_Cmd;
            }
        }
    }
 
    KdPrint2((PRINT_PREFIX "AtapiInterrupt: i-reason=%d, status=%#x\n", interruptReason, statusByte));
    if(deviceExtension->HwFlags & UNIATA_AHCI) {
        KdPrint2((PRINT_PREFIX "  AHCI path, WordsTransfered %x, WordsLeft %x\n", AtaReq->WordsTransfered, AtaReq->WordsLeft));
/*        if(chan->AhciLastIS & ATA_AHCI_P_IX_OF) {
            //status = SRB_STATUS_DATA_OVERRUN;
            DataOverrun = TRUE;
        } else {
            status = SRB_STATUS_SUCCESS;
        }*/
        if(AtaReq->WordsTransfered >= AtaReq->WordsLeft) {
            AtaReq->WordsLeft = 0;
        } else {
            AtaReq->WordsLeft -= AtaReq->WordsTransfered;
        }
        //if(AtaReq->WordsLeft && (status == SRB_STATUS_SUCCESS)) {
        //    status = SRB_STATUS_DATA_OVERRUN;
        //}
        status = SRB_STATUS_SUCCESS;
        chan->ChannelCtrlFlags &= ~CTRFLAGS_DMA_OPERATION;
        goto CompleteRequest;
    } else
    if ((interruptReason == ATAPI_IR_COD_Cmd) && (statusByte & IDE_STATUS_DRQ)) {
        if(chan->ChannelCtrlFlags & CTRFLAGS_DMA_OPERATION) {
            AtapiDmaDBPreSync(HwDeviceExtension, chan, srb);
        }
        // Write the packet.
        KdPrint3((PRINT_PREFIX "AtapiInterrupt: Writing Atapi packet.\n"));
        // Send CDB to device.
        WriteBuffer(chan, (PUSHORT)srb->Cdb,
                          LunExt->IdentifyData.AtapiCmdSize ? 8 : 6,
                          /*0*/ PIO0_TIMING);
        AtaReq->ReqState = REQ_STATE_ATAPI_EXPECTING_DATA_INTR;
 
        if(chan->ChannelCtrlFlags & CTRFLAGS_DMA_OPERATION) {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: AtapiDmaStart().\n"));
            AtapiDmaStart(HwDeviceExtension, DeviceNumber, lChannel, srb);
        }
 
        goto ReturnEnableIntr;
 
    } else if ((interruptReason == ATAPI_IR_IO_toDev) && (statusByte & IDE_STATUS_DRQ)) {
 
        // Write the data.
        if (atapiDev) {
 
            // Pick up bytes to transfer and convert to words.
            wordCount =
                AtapiReadPort1(chan, IDX_ATAPI_IO1_i_ByteCountLow);
 
            wordCount |=
                (USHORT)AtapiReadPort1(chan, IDX_ATAPI_IO1_i_ByteCountHigh) << 8;
 
            // Covert bytes to words.
            wordCount >>= 1;
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: get W wordCount %#x\n", wordCount));
 
            if (wordCount != AtaReq->WordsLeft) {
                KdPrint2((PRINT_PREFIX
                           "AtapiInterrupt: %d words requested; %d words xferred\n",
                           AtaReq->WordsLeft,
                           wordCount));
            }
 
            // Verify this makes sense.
            if (wordCount > AtaReq->WordsLeft) {
                wordCount = AtaReq->WordsLeft;
                KdPrint2((PRINT_PREFIX
                           "AtapiInterrupt: Write underrun\n"));
                DataOverrun = TRUE;
            }
 
        } else {
 
            // IDE path. Check if words left is at least DEV_BSIZE/2 = 256.
            if (AtaReq->WordsLeft < wordsThisInterrupt) {
               // Transfer only words requested.
               wordCount = AtaReq->WordsLeft;
            } else {
               // Transfer next block.
               wordCount = wordsThisInterrupt;
            }
        }
 
        if (DmaTransfer &&
            (chan->ChannelCtrlFlags & CTRFLAGS_DMA_OPERATION)) {
            //ASSERT(AtaReq->WordsLeft == wordCount);
            if(AtaReq->ReqState == REQ_STATE_ATAPI_EXPECTING_DATA_INTR2) {
                KdPrint2((PRINT_PREFIX
                          "IdeIntr: DMA tmp INTR %#x vs %#x\n", AtaReq->WordsLeft, wordCount));
                if(AtaReq->WordsLeft > wordCount) {
                    AtaReq->WordsLeft -= wordCount;
                    AtaReq->WordsTransfered += wordCount;
                    AtaReq->ReqState = REQ_STATE_ATAPI_EXPECTING_DATA_INTR;
                    goto ReturnEnableIntr;
                }
                dma_status = AtapiDmaDone(HwDeviceExtension, DEVNUM_NOT_SPECIFIED, lChannel, NULL/*srb*/);
            }
            AtaReq->WordsTransfered = AtaReq->WordsLeft;
            AtaReq->WordsLeft = 0;
            status = SRB_STATUS_SUCCESS;
            chan->ChannelCtrlFlags &= ~CTRFLAGS_DMA_OPERATION;
            goto CompleteRequest;
        }
 
        // Ensure that this is a write command.
        if (srb->SrbFlags & SRB_FLAGS_DATA_OUT) {
 
           KdPrint2((PRINT_PREFIX
                      "AtapiInterrupt: Write interrupt\n"));
 
           statusByte = WaitOnBusy(chan);
 
            if (/*atapiDev || */ !(LunExt->DeviceFlags & DFLAGS_DWORDIO_ENABLED) 
                || (wordCount & 1)) {
 
               WriteBuffer(chan,
                           AtaReq->DataBuffer,
                           wordCount,
                           UniataGetPioTiming(LunExt));
           } else {
 
               WriteBuffer2(chan,
                           (PULONG)(AtaReq->DataBuffer),
                           wordCount / 2,
                           UniataGetPioTiming(LunExt));
           }
        } else {
 
            KdPrint3((PRINT_PREFIX
                        "AtapiInterrupt: Int reason %#x, but srb is for a read %#x.\n",
                        interruptReason,
                        srb));
 
            // Fail this request.
            status = SRB_STATUS_ERROR;
            if(!wordCount && atapiDev && (srb->Cdb[0] != SCSIOP_REQUEST_SENSE)) {
                // some devices feel bad after incorrect commands and may need reset
                KdPrint2((PRINT_PREFIX
                          "AtapiInterrupt: Try ATAPI reset\n"));
 
                AtapiDisableInterrupts(deviceExtension, lChannel);
                AtapiSoftReset(chan, DeviceNumber);
                AtapiEnableInterrupts(deviceExtension, lChannel);
                status = SRB_STATUS_BUS_RESET;
                AtaReq->ReqState = REQ_STATE_TRANSFER_COMPLETE;
 
//                goto IntrPrepareResetController;
            }
            goto CompleteRequest;
        }
        // Advance data buffer pointer and bytes left.
        AtaReq->DataBuffer += wordCount;
        AtaReq->WordsLeft -= wordCount;
        AtaReq->WordsTransfered += wordCount;
 
        if (atapiDev) {
            AtaReq->ReqState = REQ_STATE_ATAPI_EXPECTING_DATA_INTR;
        }
 
        goto ReturnEnableIntr;
 
    } else if (interruptReason == ATAPI_IR_IO_toHost && (statusByte & IDE_STATUS_DRQ)) {
 
continue_read_drq:
 
        if (atapiDev) {
 
            // Pick up bytes to transfer and convert to words.
            wordCount =
                (ULONG)AtapiReadPort1(chan, IDX_ATAPI_IO1_i_ByteCountLow) |
                ((ULONG)AtapiReadPort1(chan, IDX_ATAPI_IO1_i_ByteCountHigh) << 8);
 
            // Convert bytes to words.
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: get R byteCount %#x\n", wordCount));
            wordCount >>= 1;
            /*
                When ATAPI 64k PIO read is requested we may have 0xfffe byte
                count reported for 0x10000 bytes in single interrupt.
                It is not allowed to read entire 64k block with DwordIo intead of
                wait for last word.
            */
            if (wordCount != AtaReq->WordsLeft) {
                KdPrint2((PRINT_PREFIX
                           "AtapiInterrupt: %d words requested; %d words xferred\n",
                           AtaReq->WordsLeft,
                           wordCount));
            }
 
            // Verify this makes sense.
            if (wordCount > AtaReq->WordsLeft) {
                wordCount = AtaReq->WordsLeft;
                DataOverrun = TRUE;
            }
 
        } else {
 
            // Check if words left is at least 256.
            if (AtaReq->WordsLeft < wordsThisInterrupt) {
               // Transfer only words requested.
               wordCount = AtaReq->WordsLeft;
            } else {
               // Transfer next block.
               wordCount = wordsThisInterrupt;
            }
        }
 
        if(DmaTransfer &&
           (chan->ChannelCtrlFlags & CTRFLAGS_DMA_OPERATION)) {
            if(AtaReq->ReqState == REQ_STATE_ATAPI_EXPECTING_DATA_INTR2) {
                KdPrint2((PRINT_PREFIX
                          "IdeIntr: DMA tmp INTR %#x vs %#x\n", AtaReq->WordsLeft, wordCount));
                if(AtaReq->WordsLeft > wordCount) {
                    AtaReq->WordsLeft -= wordCount;
                    AtaReq->WordsTransfered += wordCount;
                    AtaReq->ReqState = REQ_STATE_ATAPI_EXPECTING_DATA_INTR;
                    goto ReturnEnableIntr;
                }
                dma_status = AtapiDmaDone(HwDeviceExtension, DEVNUM_NOT_SPECIFIED, lChannel, NULL/*srb*/);
            }
            //ASSERT(AtaReq->WordsLeft == wordCount);
            AtaReq->WordsTransfered = AtaReq->WordsLeft;
            AtaReq->WordsLeft = 0;
            status = SRB_STATUS_SUCCESS;
            chan->ChannelCtrlFlags &= ~CTRFLAGS_DMA_OPERATION;
            goto CompleteRequest;
        }
        // Ensure that this is a read command.
        if (srb->SrbFlags & SRB_FLAGS_DATA_IN) {
 
/*           KdPrint2((
                      "AtapiInterrupt: Read interrupt\n"));*/
 
            statusByte = WaitOnBusy(chan);
 
            if(wordCount&1 && atapiDev && (g_opt_VirtualMachine == VM_BOCHS)) {
                KdPrint2((PRINT_PREFIX
                          "IdeIntr: unaligned ATAPI %#x Words\n", wordCount));
            } else
            if(LunExt->DeviceFlags & DFLAGS_DWORDIO_ENABLED) {
                KdPrint2((PRINT_PREFIX
                          "IdeIntr: pre-Read %#x Dwords\n", wordCount/2));
 
                ReadBuffer2(chan,
                           (PULONG)(AtaReq->DataBuffer),
                           wordCount / 2,
                           UniataGetPioTiming(LunExt));
                // Advance data buffer pointer and bytes left.
                AtaReq->DataBuffer += wordCount & ~1;
                AtaReq->WordsLeft -= wordCount & ~1;
                AtaReq->WordsTransfered += wordCount & ~1;
                wordCount &= 1;
            }
            if (wordCount) {
                KdPrint2((PRINT_PREFIX
                           "IdeIntr: Read %#x words\n", wordCount));
 
                ReadBuffer(chan,
                          AtaReq->DataBuffer,
                          wordCount,
                          UniataGetPioTiming(LunExt));
            }
 
            KdPrint2(("IdeIntr: PIO Read AtaReq->DataBuffer %#x, srb->DataBuffer %#x\n", AtaReq->DataBuffer, (srb ? srb->DataBuffer : (void*)-1) ));
            //KdDump(AtaReq->DataBuffer, wordCount*2);
            if(srb && atapiDev && srb->Cdb[0] == SCSIOP_REQUEST_SENSE) {
                KdDump(AtaReq->DataBuffer, wordCount*2);
            }
 
            GetBaseStatus(chan, statusByte);
            KdPrint2((PRINT_PREFIX "  status re-check %#x\n", statusByte));
 
            if(DataOverrun) {
                KdPrint2((PRINT_PREFIX "  DataOverrun\n"));
                AtapiSuckPort2(chan);
                GetBaseStatus(chan, statusByte);
            }
 
            if(statusByte & IDE_STATUS_BUSY) {
                for (i = 0; i < 2; i++) {
                    AtapiStallExecution(10);
                    GetBaseStatus(chan, statusByte);
                    if (!(statusByte & IDE_STATUS_BUSY)) {
                        break;
                    }
                }
            }
 
        } else {
 
            KdPrint3((PRINT_PREFIX
                        "AtapiInterrupt: Int reason %#x, but srb is for a read %#x.\n",
                        interruptReason,
                        srb));
 
            // Fail this request.
            status = SRB_STATUS_ERROR;
            goto CompleteRequest;
        }
//continue_atapi_pio_read:
        // Advance data buffer pointer and bytes left.
        AtaReq->DataBuffer += wordCount;
        AtaReq->WordsLeft -= wordCount;
        AtaReq->WordsTransfered += wordCount;
 
        // Check for read command complete.
        if (AtaReq->WordsLeft == 0) {
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: all transferred, AtaReq->WordsLeft == 0\n"));
            if (atapiDev) {
 
                if(LunExt->IdentifyData.DeviceType == ATAPI_TYPE_CDROM) {
 
                    // Work around to make many atapi devices return correct sector size
                    // of 2048. Also certain devices will have sector count == 0x00, check
                    // for that also.
                    if (srb->Cdb[0] == SCSIOP_READ_CAPACITY) {
 
                        AtaReq->DataBuffer -= AtaReq->WordsTransfered;
                        if (AtaReq->DataBuffer[0] == 0x00) {
                            *((ULONG *) &(AtaReq->DataBuffer[0])) = 0xFFFFFF7F;
                        }
 
                        *((ULONG *) &(AtaReq->DataBuffer[2])) = 0x00080000;
                        AtaReq->DataBuffer += AtaReq->WordsTransfered;
                    }
#ifndef UNIATA_INIT_CHANGERS
                    else
                    if (srb->Cdb[0] == SCSIOP_MECHANISM_STATUS) {
 
                        KdPrint3((PRINT_PREFIX "AtapiInterrupt: SCSIOP_MECHANISM_STATUS status %#x\n", status));
                        // Bingo!!
                        AtapiHwInitializeChanger (HwDeviceExtension,
                                                  srb,
                                                  (PMECHANICAL_STATUS_INFORMATION_HEADER) srb->DataBuffer);
                        LunExt->DeviceFlags |= DFLAGS_CHANGER_INITED;
                        KdPrint2((PRINT_PREFIX "  set DFLAGS_CHANGER_INITED\n"));
                    }
#endif // UNIATA_INIT_CHANGERS
                }
                GetStatus(chan, statusByte);
                if(!(statusByte & IDE_STATUS_BUSY)) {
                    // Assume command is completed if BUSY is cleared
                    // and all data read
                    // Optionally, we may receive COMPLETE interrupt later and
                    // treat it as unexpected
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: early complete ? status %x\n", statusByte));
 
                    status = SRB_STATUS_SUCCESS;
                    goto CompleteRequest;
                }
 
            } else {
 
            /*
                // Completion for IDE drives.
                if (AtaReq->WordsLeft) {
                    status = SRB_STATUS_DATA_OVERRUN;
                } else {
                    status = SRB_STATUS_SUCCESS;
                }
 
                goto CompleteRequest;
            */
                status = SRB_STATUS_SUCCESS;
                goto CompleteRequest;
 
            }
        } else {
            if (atapiDev) {
                AtaReq->ReqState = REQ_STATE_ATAPI_EXPECTING_DATA_INTR;
                GetStatus(chan, statusByte);
                if(!(statusByte & IDE_STATUS_BUSY)) {
                    // Assume command is completed if BUSY is cleared
                    // even if NOT all data read
                    // Optionally, we may receive COMPLETE interrupt later and
                    // treat it as unexpected
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: early complete + underrun ? status %x\n", statusByte));
 
                    status = SRB_STATUS_SUCCESS;
                    goto CompleteRequest;
                }
            } else {
                if(!atapiDev && !DataOverrun && (srb->SrbFlags & SRB_FLAGS_DATA_IN) &&
                    ((statusByte & ~IDE_STATUS_INDEX) == (IDE_STATUS_IDLE | IDE_STATUS_DRQ))) {
                    KdPrint2((PRINT_PREFIX "  HDD read data ready \n"));
                    goto continue_read_drq;
                }
            }
        }
 
        goto ReturnEnableIntr;
 
    } else if (interruptReason == (ATAPI_IR_IO_toHost | ATAPI_IR_COD_Cmd) && !(statusByte & IDE_STATUS_DRQ)) {
 
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: interruptReason = CompleteRequest\n"));
        // Command complete. We exactly know this because of IReason.
 
        if(DmaTransfer) {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: CompleteRequest, was DmaTransfer\n"));
            AtaReq->WordsTransfered += AtaReq->WordsLeft;
            AtaReq->WordsLeft = 0;
        } else {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: CompleteRequest, was PIO\n"));
 
            wordCount = AtaReq->WordsLeft;
            // Advance data buffer pointer and bytes left.
            AtaReq->DataBuffer += wordCount;
            AtaReq->WordsLeft -= wordCount;
            AtaReq->WordsTransfered += wordCount;
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: wordCount %#x, WordsTransfered %#x\n", wordCount, AtaReq->WordsTransfered));
 
        }
        //if (AtaReq->WordsLeft) {
        //    status = SRB_STATUS_DATA_OVERRUN;
        //} else {
            status = SRB_STATUS_SUCCESS;
        //}
 
#ifdef UNIATA_DUMP_ATAPI
        if(srb &&
           srb->SrbFlags & SRB_FLAGS_DATA_IN) {
            UCHAR                   ScsiCommand;
            PCDB                    Cdb;
            PCHAR                   CdbData;
            PCHAR                   ModeSelectData;
            ULONG                   CdbDataLen;
            PSCSI_REQUEST_BLOCK     Srb = srb;
 
            Cdb = (PCDB)(Srb->Cdb);
            ScsiCommand = Cdb->CDB6.OperationCode;
            CdbData = (PCHAR)(Srb->DataBuffer);
            CdbDataLen = Srb->DataTransferLength;
 
            if(CdbDataLen > 0x1000) {
                CdbDataLen = 0x1000;
            }
 
            KdPrint(("--\n"));
            KdPrint2(("DeviceID+VendorID/Rev %#x/%#x\n", deviceExtension->DevID, deviceExtension->RevID));
            KdPrint2(("P:T:D=%d:%d:%d\n",
                                      Srb->PathId,
                                      Srb->TargetId,
                                      Srb->Lun));
            KdPrint(("Complete SCSI Command %2.2x\n", ScsiCommand));
            KdDump(Cdb, 16);
 
            if(ScsiCommand == SCSIOP_MODE_SENSE) {
                KdPrint(("ModeSense 6\n"));
                PMODE_PARAMETER_HEADER ParamHdr = (PMODE_PARAMETER_HEADER)CdbData;
                ModeSelectData = CdbData+4;
                KdDump(CdbData, CdbDataLen);
            } else
            if(ScsiCommand == SCSIOP_MODE_SENSE10) {
                KdPrint(("ModeSense 10\n"));
                PMODE_PARAMETER_HEADER ParamHdr = (PMODE_PARAMETER_HEADER)CdbData;
                ModeSelectData = CdbData+8;
                KdDump(CdbData, CdbDataLen);
            } else {
                if(srb->SrbFlags & SRB_FLAGS_DATA_IN) {
                    KdPrint(("Read buffer from device:\n"));
                    KdDump(CdbData, CdbDataLen);
                }
            }
            KdPrint(("--\n"));
        }
#endif //UNIATA_DUMP_ATAPI
 
CompleteRequest:
 
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: CompleteRequest, srbstatus %x\n", status));
        // Check and see if we are processing our secret (mechanism status/request sense) srb
 
        if(AtaReq->WordsLeft && (status == SRB_STATUS_SUCCESS)) {
            KdPrint2((PRINT_PREFIX "WordsLeft %#x -> SRB_STATUS_DATA_OVERRUN\n", AtaReq->WordsLeft));
            status = SRB_STATUS_DATA_OVERRUN;
        }
 
        if (AtaReq->OriginalSrb) {
 
            ULONG srbStatus;
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: OriginalSrb != NULL\n"));
            if (srb->Cdb[0] == SCSIOP_MECHANISM_STATUS) {
#ifdef UNIATA_INIT_CHANGERS
                // We can get here only when UNIATA_INIT_CHANGERS is defined
                KdPrint3((PRINT_PREFIX "AtapiInterrupt: SCSIOP_MECHANISM_STATUS status %#x\n", status));
                if (status == SRB_STATUS_SUCCESS) {
                    // Bingo!!
                    AtapiHwInitializeChanger (HwDeviceExtension,
                                              srb,
                                              (PMECHANICAL_STATUS_INFORMATION_HEADER) srb->DataBuffer);
 
                    // Get ready to issue the original srb
                    srb = AtaReq->Srb = AtaReq->OriginalSrb;
                    AtaReq->OriginalSrb = NULL;
 
                } else {
                    // failed!  Get the sense key and maybe try again
                    srb = AtaReq->Srb = BuildRequestSenseSrb (
                                                          HwDeviceExtension,
                                                          AtaReq->OriginalSrb);
                }
/*
                // do not enable interrupts in DPC, do not waste time, do it now!
                if(UseDpc && chan->DisableIntr) {
                    AtapiEnableInterrupts(HwDeviceExtension, c);
                    UseDpc = FALSE;
                    RestoreUseDpc = TRUE;
                }
*/
                srbStatus = AtapiSendCommand(HwDeviceExtension, srb, CMD_ACTION_ALL);
 
                KdPrint3((PRINT_PREFIX "AtapiInterrupt: chan->ExpectingInterrupt %d (1)\n", chan->ExpectingInterrupt));
 
                if (srbStatus == SRB_STATUS_PENDING) {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: send orig SRB_STATUS_PENDING (1)\n"));
                    goto ReturnEnableIntr;
                }
/*
                if(RestoreUseDpc) {
                    // restore state on error
                    UseDpc = TRUE;
                    AtapiDisableInterrupts(HwDeviceExtension, c);
                }
*/
#else
                KdPrint((PRINT_PREFIX "AtapiInterrupt: ERROR: internal SCSIOP_MECHANISM_STATUS !!!!\n"));
                ASSERT(FALSE);
#endif // UNIATA_INIT_CHANGERS
            } else { // srb->Cdb[0] == SCSIOP_REQUEST_SENSE)
 
                PSENSE_DATA senseData = (PSENSE_DATA) srb->DataBuffer;
#ifdef __REACTOS__
                (void)senseData;
#endif
 
                KdPrint3((PRINT_PREFIX "AtapiInterrupt: ATAPI command status %#x\n", status));
                if (status == SRB_STATUS_DATA_OVERRUN) {
                    // Check to see if we at least get mininum number of bytes
                    if ((srb->DataTransferLength - AtaReq->WordsLeft) >
                        (FIELD_OFFSET (SENSE_DATA, AdditionalSenseLength) + sizeof(senseData->AdditionalSenseLength))) {
                        status = SRB_STATUS_SUCCESS;
                    }
                }
 
                if (status == SRB_STATUS_SUCCESS) {
#ifndef UNIATA_CORE
#ifdef UNIATA_INIT_CHANGERS
                    if ((senseData->SenseKey != SCSI_SENSE_ILLEGAL_REQUEST) &&
                        FALSE &&
                        chan->MechStatusRetryCount) {
 
                        KdPrint3((PRINT_PREFIX "AtapiInterrupt: MechStatusRetryCount %#x\n", chan->MechStatusRetryCount));
                        // The sense key doesn't say the last request is illegal, so try again
                        chan->MechStatusRetryCount--;
                        srb = AtaReq->Srb = BuildMechanismStatusSrb (
                                                              HwDeviceExtension,
                                                              AtaReq->OriginalSrb);
                    } else
#endif // UNIATA_INIT_CHANGERS
                    {
                        // Get ready to issue the original srb
                        srb = AtaReq->Srb = AtaReq->OriginalSrb;
                        AtaReq->OriginalSrb = NULL;
                    }
#endif //UNIATA_CORE
/*
                    // do not enable interrupts in DPC, do not waste time, do it now!
                    if(UseDpc && chan->DisableIntr) {
                        AtapiEnableInterrupts(HwDeviceExtension, c);
                        UseDpc = FALSE;
                        RestoreUseDpc = TRUE;
                    }
*/
                    srbStatus = AtapiSendCommand(HwDeviceExtension, srb, CMD_ACTION_ALL);
 
                    KdPrint3((PRINT_PREFIX "AtapiInterrupt: chan->ExpectingInterrupt %d (2)\n", chan->ExpectingInterrupt));
 
                    if (srbStatus == SRB_STATUS_PENDING) {
                        KdPrint2((PRINT_PREFIX "AtapiInterrupt: send orig SRB_STATUS_PENDING (2)\n"));
                        goto ReturnEnableIntr;
                    }
/*
                    if(RestoreUseDpc) {
                        // restore state on error
                        UseDpc = TRUE;
                        AtapiDisableInterrupts(HwDeviceExtension, c);
                    }
*/
                }
            }
 
            // If we get here, it means AtapiSendCommand() has failed
            // Can't recover.  Pretend the original srb has failed and complete it.
 
            KdPrint3((PRINT_PREFIX "AtapiInterrupt: Error. complete OriginalSrb\n"));
 
            if (AtaReq->OriginalSrb) {
                srb = AtaReq->Srb = AtaReq->OriginalSrb;
                AtaReq->OriginalSrb = NULL;
            }
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: chan->ExpectingInterrupt %d (3)\n", chan->ExpectingInterrupt));
 
            // fake an error and read no data
            status = SRB_STATUS_ERROR;
            srb->ScsiStatus = 0;
            AtaReq->DataBuffer = (PUSHORT)(srb->DataBuffer);
            AtaReq->WordsLeft = srb->DataTransferLength;
            chan->RDP = FALSE;
 
        } else if (status == SRB_STATUS_ERROR) {
 
            // Map error to specific SRB status and handle request sense.
            KdPrint3((PRINT_PREFIX "AtapiInterrupt: Error. Begin mapping...\n"));
            status = MapError(deviceExtension,
                              srb);
 
            chan->RDP = FALSE;
 
        } else if(!DmaTransfer) {
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: PIO completion\n"));
            // Command complete.
PIO_wait_busy:
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: PIO completion, wait BUSY\n"));
            // Wait for busy to drop.
            for (i = 0; i < 5*30; i++) {
                GetBaseStatus(chan, statusByte);
                if (!(statusByte & IDE_STATUS_BUSY)) {
                    break;
                }
                if(!InDpc) {
                    // goto DPC
                    AtaReq->ReqState = REQ_STATE_DPC_WAIT_BUSY;
                    TimerValue = 200;
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: go to DPC (busy)\n"));
#ifndef UNIATA_CORE
                    goto PostToDpc;
#else //UNIATA_CORE
                    AtapiStallExecution(TimerValue);
                    goto ServiceInterrupt;
#endif //UNIATA_CORE
                }
                AtapiStallExecution(100);
            }
 
            if (i == 5*30) {
 
                // reset the controller.
                KdPrint2((PRINT_PREFIX
                            "AtapiInterrupt: Resetting due to BSY still up - %#x.\n",
                            statusByte));
                goto IntrPrepareResetController;
            }
            // Check to see if DRQ is still up.
            if(statusByte & IDE_STATUS_DRQ) {
                KdPrint2((PRINT_PREFIX "AtapiInterrupt: DRQ...\n"));
                if(srb) {
                    if(srb->SrbFlags & SRB_FLAGS_DATA_IN) {
                        KdPrint2((PRINT_PREFIX "srb %x data in\n", srb));
                    } else {
                        KdPrint2((PRINT_PREFIX "srb %x data out\n", srb));
                    }
                } else {
                    KdPrint2((PRINT_PREFIX "srb NULL\n"));
                }
                if(AtaReq) {
                    KdPrint2((PRINT_PREFIX "AtaReq %x AtaReq->WordsLeft=%x\n", AtaReq, AtaReq->WordsLeft));
                } else {
                    KdPrint2((PRINT_PREFIX "AtaReq NULL\n"));
                }
                if(AtaReq && AtaReq->WordsLeft /*&&
                   !(LunExt->DeviceFlags & (DFLAGS_ATAPI_DEVICE | DFLAGS_TAPE_DEVICE | DFLAGS_LBA_ENABLED))*/) {
                    KdPrint2((PRINT_PREFIX "DRQ+AtaReq->WordsLeft -> next portion\n"));
                    goto continue_PIO;
                }
            }
            //if (atapiDev && (statusByte & IDE_STATUS_DRQ)) {}
            //if ((statusByte & IDE_STATUS_DRQ)) {}
            if((statusByte & IDE_STATUS_DRQ) &&
               (LunExt->DeviceFlags & (DFLAGS_ATAPI_DEVICE | DFLAGS_TAPE_DEVICE | DFLAGS_LBA_ENABLED)) ) {
 
PIO_wait_DRQ:
                KdPrint2((PRINT_PREFIX "AtapiInterrupt: PIO_wait_DRQ\n"));
                for (i = 0; i < 200; i++) {
                    GetBaseStatus(chan, statusByte);
                    if (!(statusByte & IDE_STATUS_DRQ)) {
                        break;
                    }
                    if(!InDpc) {
                        // goto DPC
                        KdPrint2((PRINT_PREFIX "AtapiInterrupt: go to DPC (drq)\n"));
                        AtaReq->ReqState = REQ_STATE_DPC_WAIT_DRQ;
                        TimerValue = 100;
#ifndef UNIATA_CORE
                        goto PostToDpc;
#else //UNIATA_CORE
                        AtapiStallExecution(TimerValue);
                        goto ServiceInterrupt;
#endif //UNIATA_CORE
                    }
                    AtapiStallExecution(100);
                }
 
                if (i == 200) {
                    // reset the controller.
                    KdPrint2((PRINT_PREFIX   "AtapiInterrupt: Resetting due to DRQ still up - %#x\n",
                                statusByte));
                    goto IntrPrepareResetController;
                }
            }
            if(atapiDev) {
                KdPrint2(("IdeIntr: ATAPI Read AtaReq->DataBuffer %#x, srb->DataBuffer %#x, len %#x\n",
                     AtaReq->DataBuffer, (srb ? srb->DataBuffer : (void*)(-1)), srb->DataTransferLength ));
                //KdDump(srb->DataBuffer, srb->DataTransferLength);
            }
            if(!AtapiDmaPioSync(HwDeviceExtension, srb, (PUCHAR)(srb->DataBuffer), srb->DataTransferLength)) {
                KdPrint2(("IdeIntr: Can't sync DMA and PIO buffers\n"));
            }
        }
 
        // Clear interrupt expecting flag.
        UniataExpectChannelInterrupt(chan, FALSE);
        // clear this flag now, it can be set again in sub-calls
        InterlockedExchange(&(chan->CheckIntr),
                                      CHECK_INTR_IDLE);
 
        // Sanity check that there is a current request.
        if(srb != NULL) {
            // Set status in SRB.
            srb->SrbStatus = (UCHAR)status;
 
            // Check for underflow.
            if(AtaReq->WordsLeft) {
 
                KdPrint2((PRINT_PREFIX "AtapiInterrupt: Check for underflow, AtaReq->WordsLeft %x\n", AtaReq->WordsLeft));
                // Subtract out residual words and update if filemark hit,
                // setmark hit , end of data, end of media...
                if (!(LunExt->DeviceFlags & DFLAGS_TAPE_DEVICE)) {
                    if (status == SRB_STATUS_DATA_OVERRUN) {
                        srb->DataTransferLength -= AtaReq->WordsLeft*2;
                    } else {
                        srb->DataTransferLength = 0;
                    }
                } else {
                    srb->DataTransferLength -= AtaReq->WordsLeft*2;
                }
            }
            if(status == SRB_STATUS_SUCCESS) {
                //if(!(deviceExtension->HwFlags & UNIATA_AHCI) && !atapiDev) {
                //    // This should be set in UniataAhciEndTransaction() for AHCI
                //    AtaReq->WordsTransfered += AtaReq->bcount * DEV_BSIZE/2;
                //}
                if(!atapiDev &&
                   AtaReq->WordsTransfered*2 < AtaReq->TransferLength) {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: more I/O required (%x of %x bytes) -> reenqueue\n",
                         AtaReq->WordsTransfered*2, AtaReq->TransferLength));
                    AtaReq->Flags &= ~REQ_FLAG_DMA_OPERATION;
                    AtaReq->ReqState = REQ_STATE_PREPARE_TO_NEXT;
                    goto reenqueue_req;
                } else {
                    KdPrint2((PRINT_PREFIX "   Transfered %x, full size %x\n",
                        AtaReq->WordsTransfered*2, AtaReq->TransferLength));
                }
            }
 
            if (srb->Function != SRB_FUNCTION_IO_CONTROL) {
 
CompleteRDP:
                // Indicate command complete.
                if (!(chan->RDP)) {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: RequestComplete\n"));
IntrCompleteReq:
 
                    if (status == SRB_STATUS_SUCCESS &&
                        srb->SenseInfoBuffer &&
                        srb->SenseInfoBufferLength >= sizeof(SENSE_DATA)) {
 
                        PSENSE_DATA  senseBuffer = (PSENSE_DATA)srb->SenseInfoBuffer;
 
                        KdPrint2((PRINT_PREFIX "AtapiInterrupt: set AutoSense\n"));
                        senseBuffer->ErrorCode = 0;
                        senseBuffer->Valid     = 1;
                        senseBuffer->AdditionalSenseLength = 0xb;
                        senseBuffer->SenseKey =  0;
                        senseBuffer->AdditionalSenseCode = 0;
                        senseBuffer->AdditionalSenseCodeQualifier = 0;
 
                        srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
                    }
                    AtapiDmaDBSync(chan, srb);
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: remove srb %#x, status %x\n", srb, status));
                    UniataRemoveRequest(chan, srb);
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: RequestComplete, srb %#x\n", srb));
                    ScsiPortNotification(RequestComplete,
                                         deviceExtension,
                                         srb);
                }
            } else {
 
                KdPrint2((PRINT_PREFIX "AtapiInterrupt: IOCTL completion\n"));
 
                if (status != SRB_STATUS_SUCCESS) {
                    error = AtapiReadPort1(chan, IDX_IO1_i_Error);
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: error %#x\n", error));
                }
 
                if(!AtapiStringCmp( (PCHAR)(((PSRB_IO_CONTROL)(srb->DataBuffer))->Signature),"SCSIDISK",sizeof("SCSIDISK")-1)) {
 
                    PSENDCMDOUTPARAMS cmdOutParameters = (PSENDCMDOUTPARAMS)(((PUCHAR)srb->DataBuffer) + sizeof(SRB_IO_CONTROL));
                    // Build the SMART status block depending upon the completion status.
                    cmdOutParameters->cBufferSize = wordCount;
                    cmdOutParameters->DriverStatus.bDriverError = (error) ? SMART_IDE_ERROR : 0;
                    cmdOutParameters->DriverStatus.bIDEError = error;
 
                    // If the sub-command is return smart status, jam the value from cylinder low and high, into the
                    // data buffer.
                    if (chan->SmartCommand == RETURN_SMART_STATUS) {
                        PIDEREGS_EX regs = (PIDEREGS_EX)&(cmdOutParameters->bBuffer);
 
                        regs->bOpFlags = 0;
                        UniataSnapAtaRegs(chan, 0, regs);
 
                        regs->bCommandReg = SMART_CMD;
                        regs->bFeaturesReg = RETURN_SMART_STATUS;
 
                        cmdOutParameters->cBufferSize = 8;
                    }
                    chan->SmartCommand = 0; // cleanup after execution
                }
                // Indicate command complete.
                goto IntrCompleteReq;
            }
 
        } else {
 
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: No SRB!\n"));
        }
 
        if (chan->RDP) {
            // Check DSC
            for (i = 0; i < 5; i++) {
                GetBaseStatus(chan, statusByte);
                if(!(statusByte & IDE_STATUS_BUSY)) {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: RDP + cleared BUSY\n"));
                    chan->RDP = FALSE;
                    goto CompleteRDP;
                } else
                if (statusByte & IDE_STATUS_DSC) {
                    KdPrint2((PRINT_PREFIX "AtapiInterrupt: Clear RDP\n"));
                    chan->RDP = FALSE;
                    goto CompleteRDP;
                }
                AtapiStallExecution(50);
            }
        }
        // RDP can be cleared since previous check
        if (chan->RDP) {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: RequestTimerCall 2000\n"));
 
            TimerValue = 2000;
#ifndef UNIATA_CORE
            goto CallTimerDpc;
#else //UNIATA_CORE
            AtapiStallExecution(TimerValue);
            goto ServiceInterrupt;
#endif //UNIATA_CORE
        }
 
//            ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
enqueue_next_req:
        // Get next request
        srb = UniataGetCurRequest(chan);
 
reenqueue_req:
 
#ifndef UNIATA_CORE
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: NextRequest, srb=%#x\n",srb));
        if(!srb) {
            ScsiPortNotification(NextRequest,
                                 deviceExtension,
                                 NULL);
        } else {
            ScsiPortNotification(NextLuRequest,
                                 deviceExtension,
                                 PathId,
                                 TargetId,
                                 Lun);
            // in simplex mode next command must NOT be sent here
            if(!deviceExtension->simplexOnly) {
                AtapiStartIo__(HwDeviceExtension, srb, FALSE);
            }
        }
        // Try to get SRB fron any non-empty queue (later)
        if(deviceExtension->simplexOnly) {
            NoStartIo = FALSE;
        }
#endif //UNIATA_CORE
 
        goto ReturnEnableIntr;
 
    } else {
 
        // Unexpected int. Catch it
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: Unexpected ATAPI interrupt. InterruptReason %#x. Status %#x.\n",
                    interruptReason,
                    statusByte));
 
        if(g_opt_VirtualMachine == VM_QEMU) {
            if(interruptReason == ATAPI_IR_IO_toDev && !(statusByte & IDE_STATUS_DRQ) && !DmaTransfer) {
                statusByte = WaitForDrq(chan);
                if(statusByte & IDE_STATUS_DRQ) {
                    goto continue_PIO;
                }
            }
        }
 
        if(OldReqState == REQ_STATE_DPC_WAIT_BUSY0 &&
           AtaReq->WordsLeft == 0) {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: pending WAIT_BUSY0. Complete.\n"));
            status = SRB_STATUS_SUCCESS;
            chan->ChannelCtrlFlags &= ~CTRFLAGS_DMA_OPERATION;
            goto CompleteRequest;
        }
    }
 
ReturnEnableIntr:
 
    KdPrint2((PRINT_PREFIX "AtapiInterrupt: ReturnEnableIntr\n",srb));
    //UniataExpectChannelInterrupt(chan, TRUE); // device may interrupt
    deviceExtension->ExpectingInterrupt = TRUE;
    if(UseDpc) {
        if(CrNtInterlockedExchangeAdd(&(chan->DisableIntr), 0)) {
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: call AtapiEnableInterrupts__()\n"));
#ifdef UNIATA_USE_XXableInterrupts
            //ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
            chan->ChannelCtrlFlags |= CTRFLAGS_ENABLE_INTR_REQ;
            // must be called on DISPATCH_LEVEL
            ScsiPortNotification(CallDisableInterrupts, HwDeviceExtension,
                                 AtapiEnableInterrupts__);
#else
            AtapiEnableInterrupts(HwDeviceExtension, c);
            InterlockedExchange(&(chan->CheckIntr),
                                          CHECK_INTR_IDLE);
            // Will raise IRQL to DIRQL
#ifndef UNIATA_CORE
            AtapiQueueTimerDpc(HwDeviceExtension, lChannel,
                                 AtapiEnableInterrupts__,
                                 1);
#endif // UNIATA_CORE
            KdPrint2((PRINT_PREFIX "AtapiInterrupt: Timer DPC inited\n"));
#endif // UNIATA_USE_XXableInterrupts
        }
    }
 
    InterlockedExchange(&(chan->CheckIntr), CHECK_INTR_IDLE);
    // in simplex mode next command must be sent here if
    // DPC is not used
    KdPrint2((PRINT_PREFIX "AtapiInterrupt: exiting, UseDpc=%d, NoStartIo=%d\n", UseDpc, NoStartIo));
 
#ifndef UNIATA_CORE
    if(!UseDpc && /*deviceExtension->simplexOnly &&*/ !NoStartIo) {
        chan = UniataGetNextChannel(chan);
        if(chan) {
            srb = UniataGetCurRequest(chan);
        } else {
            srb = NULL;
        }
        KdPrint2((PRINT_PREFIX "AtapiInterrupt: run srb %x\n", srb));
        if(srb) {
            AtapiStartIo__(HwDeviceExtension, srb, FALSE);
        }
    }
#endif //UNIATA_CORE
    return TRUE;
 
} // end AtapiInterrupt__()