id_ata.cpp

Go to the documentation of this file.

/*++
 
Copyright (c) 2002-2018 Alexandr A. Telyatnikov (Alter)
 
Module Name:
    id_ata.cpp
 
Abstract:
    This is the miniport driver for ATA/ATAPI IDE/SATA/AHCI controllers
    with Busmaster DMA and Serial ATA support
 
Author:
    Alexander A. Telyatnikov (Alter)
 
Environment:
    kernel mode only
 
Notes:
 
    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
Revision History:
 
    The skeleton was taken from standard ATAPI.SYS from NT4 DDK by
         Mike Glass (MGlass)
         Chuck Park (ChuckP)
 
    Some parts of code were taken from FreeBSD 4.3-6.1 ATA driver by
         Søren Schmidt, Copyright (c) 1998-2007
 
    All parts of code are significantly changed/updated by
         Alter, Copyright (c) 2002-2014:
 
    1. Internal command queueing/reordering
    2. Drive identification
    3. Support for 2 _independent_ channels in a single PCI device
    4. Smart host<->drive transfer rate slowdown (for bad cable)
    5. W2k support (binary compatibility)
    6. HDD hot swap under NT4
    7. XP support (binary compatibility)
    8. Serial ATA (SATA/SATA2/SATA3) support
    9. NT 3.51 support (binary compatibility)
    10. AHCI support
 
    etc. (See todo.txt)
 
Licence:
    GPLv2
 
--*/
 
#include "stdafx.h"
 
#ifndef UNIATA_CORE
 
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];
 
#endif //UNIATA_CORE
 
//UCHAR AtaCommands48[256];
//UCHAR AtaCommandFlags[256];
 
ULONG  SkipRaids = 1;
ULONG  ForceSimplex = 0;
 
LONGLONG g_Perf = 0;
ULONG    g_PerfDt = 0;
 
#ifdef _DEBUG
ULONG  g_LogToDisplay = 0;
#endif //_DEBUG
 
ULONG  g_WaitBusyInISR = 1;
 
ULONG  g_opt_WaitBusyResetCount = 10000; // 20000
ULONG  g_opt_WaitBusyCount = 200; // 20000
ULONG  g_opt_WaitBusyDelay = 10;  // 150
ULONG  g_opt_WaitDrqDelay  = 10; // 100
ULONG  g_opt_WaitBusyLongCount = 2000; // 2000
ULONG  g_opt_WaitBusyLongDelay = 250;  // 250
ULONG  g_opt_MaxIsrWait = 40;
 
ULONG  g_opt_DriveSelectNanoDelay = 0; // 400; // ns
 
BOOLEAN g_opt_AtapiSendDisableIntr = 0; // 0
BOOLEAN g_opt_AtapiDmaRawRead = 1; // 0
BOOLEAN g_opt_AtapiNoDma = FALSE;
BOOLEAN g_opt_BochsDmaReadWorkaround = FALSE;
BOOLEAN hasPCI = FALSE;
 
ULONG g_opt_VirtualMachine = 0; // Auto
 
BOOLEAN InDriverEntry = TRUE;
BOOLEAN g_Dump = FALSE;
 
BOOLEAN g_opt_Verbose = 0;
 
BOOLEAN WinVer_WDM_Model = FALSE;
ULONG CPU_num = 1;
 
//UCHAR EnableDma = FALSE;
//UCHAR EnableReorder = FALSE;
 
UCHAR g_foo = 0;
 
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
    );
 
#define RESET_COMPLETE_CURRENT  0x00
#define RESET_COMPLETE_ALL      0x01
#define RESET_COMPLETE_NONE     0x02
 
#ifndef UNIATA_CORE
 
VOID
NTAPI
AtapiCallBack_X(
    IN PVOID HwDeviceExtension
    );
 
#ifdef UNIATA_USE_XXableInterrupts
  #define RETTYPE_XXableInterrupts   BOOLEAN
  #define RETVAL_XXableInterrupts    TRUE
#else
  #define RETTYPE_XXableInterrupts   VOID
  #define RETVAL_XXableInterrupts
#endif
 
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
    );
 
#endif //UNIATA_CORE
 
#ifndef UNIATA_CORE
 
BOOLEAN
NTAPI
AtapiRegGetStringParameterValue(
    IN PWSTR RegistryPath,
    IN PWSTR Name,
    IN PWCHAR Str,
    IN ULONG MaxLen
    )
{
#define ITEMS_TO_QUERY 2 // always 1 greater than what is searched
    NTSTATUS          status;
    RTL_QUERY_REGISTRY_TABLE parameters[ITEMS_TO_QUERY];
    UNICODE_STRING ustr;
 
    ustr.Buffer = Str;
    ustr.Length =
    ustr.MaximumLength = (USHORT)MaxLen;
    RtlZeroMemory(parameters, (sizeof(RTL_QUERY_REGISTRY_TABLE)*ITEMS_TO_QUERY));
 
    parameters[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    parameters[0].Name          = Name;
    parameters[0].EntryContext  = &ustr;
    parameters[0].DefaultType   = REG_SZ;
    parameters[0].DefaultData   = Str;
    parameters[0].DefaultLength = MaxLen;
 
    status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE /*| RTL_REGISTRY_OPTIONAL*/,
                                    RegistryPath, parameters, NULL, NULL);
 
    if(!NT_SUCCESS(status))
        return FALSE;
 
    return TRUE;
 
#undef ITEMS_TO_QUERY
} // end AtapiRegGetStringParameterValue()
 
 
#endif //UNIATA_CORE
 
VOID
DDKFASTAPI
UniataNanoSleep(
    ULONG nano
    )
{
    LONGLONG t;
    LARGE_INTEGER t0;
 
#ifdef NAVO_TEST
    return;
#endif //NAVO_TEST
 
    if(!nano || !g_Perf || !g_PerfDt)
        return;
    t = (g_Perf * nano) / g_PerfDt / 1000;
    if(!t) {
        t = 1;
    }
    do {
        KeQuerySystemTime(&t0);
        t--;
    } while(t);
} // end UniataNanoSleep()
 
#define AtapiWritePortN_template(_type, _Type, sz) \
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;                                                  \
}
 
AtapiWritePortN_template(ULONG,  Ulong,  4);
AtapiWritePortN_template(USHORT, Ushort, 2);
AtapiWritePortN_template(UCHAR,  Uchar,  1);
 
#define AtapiWritePortExN_template(_type, _Type, sz) \
VOID \
DDKFASTAPI \
AtapiWritePortEx##sz( \
    IN PHW_CHANNEL chan, \
    IN ULONGIO_PTR _port, \
    IN ULONG offs, \
    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, offs %x\n", chan, _port, offs)); \
        return; \
    } \
    if(res->Proc) {             \
        KdPrint(("PROC io write request @ ch %x, res* %x, offs %x\n", chan, _port, offs)); \
        ASSERT(FALSE); /* We should never get here */ \
    } \
    if(!res->MemIo) {             \
        ScsiPortWritePort##_Type((_type*)(ULONGIO_PTR)(res->Addr+offs), data); \
    } else {                                      \
        /*KdPrint(("r_mem @ (%x) %x\n", _port, port));*/ \
        ScsiPortWriteRegister##_Type((_type*)(ULONG_PTR)(res->Addr+offs), data); \
    }                                                        \
    return;                                                  \
}
 
AtapiWritePortExN_template(ULONG,  Ulong,  4);
//AtapiWritePortExN_template(USHORT, Ushort, 2);
AtapiWritePortExN_template(UCHAR,  Uchar,  1);
 
#define AtapiReadPortN_template(_type, _Type, sz) \
_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)); \
    }                                                        \
}
 
AtapiReadPortN_template(ULONG,  Ulong,  4);
AtapiReadPortN_template(USHORT, Ushort, 2);
AtapiReadPortN_template(UCHAR,  Uchar,  1);
 
#define AtapiReadPortExN_template(_type, _Type, sz) \
_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)); \
    }                                                        \
}
 
AtapiReadPortExN_template(ULONG,  Ulong,  4);
//AtapiReadPortExN_template(USHORT, Ushort, 2);
AtapiReadPortExN_template(UCHAR,  Uchar,  1);
 
#define AtapiReadPortBufferN_template(_type, _Type, sz) \
VOID \
DDKFASTAPI \
AtapiReadBuffer##sz( \
    IN PHW_CHANNEL chan, \
    IN ULONGIO_PTR _port, \
    IN PVOID Buffer, \
    IN ULONG Count,   \
    IN ULONG Timing   \
    ) \
{ \
    PIORES res; \
                 \
    if(Timing) { \
        while(Count) { \
            (*((_type*)Buffer)) = AtapiReadPort##sz(chan, _port); \
            Count--; \
            Buffer = ((_type*)Buffer)+1; \
            UniataNanoSleep(Timing); \
        } \
        return; \
    } \
           \
    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; \
    } \
    if(!res->MemIo) {             \
        /*KdPrint(("r_io @ (%x) %x\n", _port, res->Addr));*/ \
        ScsiPortReadPortBuffer##_Type((_type*)(ULONGIO_PTR)(res->Addr), (_type*)Buffer, Count); \
        return; \
    }                                                        \
    while(Count) { \
        (*((_type*)Buffer)) = ScsiPortReadRegister##_Type((_type*)(ULONG_PTR)(res->Addr)); \
        Count--; \
        Buffer = ((_type*)Buffer)+1; \
    } \
    return;                                                  \
}
 
#define AtapiWritePortBufferN_template(_type, _Type, sz) \
VOID \
DDKFASTAPI \
AtapiWriteBuffer##sz( \
    IN PHW_CHANNEL chan, \
    IN ULONGIO_PTR _port, \
    IN PVOID Buffer, \
    IN ULONG Count,   \
    IN ULONG Timing   \
    ) \
{ \
    PIORES res; \
                 \
    if(Timing) { \
        while(Count) { \
            AtapiWritePort##sz(chan, _port, *((_type*)Buffer)); \
            Buffer = ((_type*)Buffer)+1; \
            Count--; \
            UniataNanoSleep(Timing); \
        } \
        return;                                                  \
    } \
           \
    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->MemIo) {             \
        /*KdPrint(("r_io @ (%x) %x\n", _port, res->Addr));*/ \
        ScsiPortWritePortBuffer##_Type((_type*)(ULONGIO_PTR)(res->Addr), (_type*)Buffer, Count); \
        return; \
    }                                                        \
    while(Count) { \
        ScsiPortWriteRegister##_Type((_type*)(ULONG_PTR)(res->Addr), *((_type*)Buffer)); \
        Count--; \
        Buffer = ((_type*)Buffer)+1; \
    } \
    return;                                                  \
}
 
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
    )
{
    UCHAR statusByte;
    ULONG i;
 
    // Assume, proper drive is already seleted
    WaitOnBusyLong(chan);
    for (i = 0; i < 0x10000; i++) {
 
        GetStatus(chan, statusByte);
        if (statusByte & IDE_STATUS_DRQ) {
            // Suck out any remaining bytes and throw away.
            AtapiReadPort2(chan, IDX_IO1_i_Data);
            UniataNanoSleep(PIO0_TIMING);
        } else {
            break;
        }
    }
    if(i) {
        KdPrint2((PRINT_PREFIX "AtapiSuckPort2: overrun detected (%#x words)\n", i ));
    }
    return statusByte;
} // AtapiSuckPort2()
 
ULONG
DDKFASTAPI
AtapiSuckPortBuffer2(
    IN PHW_CHANNEL chan,
    IN PUSHORT Buffer,
    IN ULONG Count
    )
{
    UCHAR statusByte;
    ULONG i;
    USHORT data;
    BOOLEAN retry = FALSE;
 
    // Assume, proper drive is already seleted
    WaitOnBusyLong(chan);
    for (i = 0; i < Count; i++) {
 
        GetStatus(chan, statusByte);
        if (statusByte & IDE_STATUS_DRQ) {
            // Suck out any remaining bytes and throw away.
            data = AtapiReadPort2(chan, IDX_IO1_i_Data);
            (*Buffer) = data;
            Count--;
            Buffer++;
            UniataNanoSleep(PIO0_TIMING);
            retry = FALSE;
        } else {
            if(i<Count && !retry) {
                KdPrint2((PRINT_PREFIX "  wait...\n"));
                WaitForDrq(chan);
                retry = TRUE;
            }
            break;
        }
    }
    if(i) {
        KdPrint2((PRINT_PREFIX "AtapiSuckPortBuffer2: %#x words\n", i ));
        if(i==Count) {
            AtapiSuckPort2(chan);
        }
    }
    return i;
} // AtapiSuckPortBuffer2()
 
#ifdef __REACTOS__
VOID
DDKFASTAPI
FillDeviceIdentificationString(
    IN OUT PINQUIRYDATA InquiryData,
    IN PIDENTIFY_DATA2 IdentifyData)
{
    ULONG i;
    ULONG IdentifierLen, FirstWordLen;
 
    /* We need to copy a field which is 20 chars long to two fields which are 8+16 bytes long (VendorId + ProductId)
     * Note that a space will be added between those fields when displaying them.
     * => Try to split identifier on space char.
     */
 
#define IDENTIFIER_LETTER(Identifier, i) (((PUCHAR)Identifier)[(i) ^ 1])
 
    for (IdentifierLen = 20; IdentifierLen > 0 && IDENTIFIER_LETTER(IdentifyData->ModelNumber, IdentifierLen - 1) == ' '; IdentifierLen--)
        ;
 
    /* Strategy 1: copy first word to VendorId if len <= 8. Copy other chars to ProductId */
    for (FirstWordLen = 0; IDENTIFIER_LETTER(IdentifyData->ModelNumber, FirstWordLen) != ' ' && FirstWordLen < IdentifierLen; FirstWordLen++)
        ;
    if (FirstWordLen <= 8)
    {
        for (i = 0; i < FirstWordLen; i++)
            InquiryData->VendorId[i] = IDENTIFIER_LETTER(IdentifyData->ModelNumber, i);
        for (i = FirstWordLen + 1; i < IdentifierLen; i++)
            InquiryData->ProductId[i - FirstWordLen - 1] = IDENTIFIER_LETTER(IdentifyData->ModelNumber, i);
        return;
    }
 
    /* Strategy 2: copy everything to ProductId */
    if (IdentifierLen <= 16)
    {
        for (i = 0; i < IdentifierLen; i++)
            InquiryData->ProductId[i] = IDENTIFIER_LETTER(IdentifyData->ModelNumber, i);
        return;
    }
 
    /* Strategy 3: copy first to VendorId, then to ProductId */
    for (i = 0; i < 24; i += 2)
        MOV_DW_SWP(InquiryData->DeviceIdentificationString[i], ((PUCHAR)IdentifyData->ModelNumber)[i]);
}
#endif
 
UCHAR
DDKFASTAPI
SelectDrive(
    IN PHW_CHANNEL   chan,
    IN ULONG         DeviceNumber
    )
{
    if(!chan) {
        return 0;
    }
/*
    if(chan->lun[DeviceNumber] &&
       (chan->lun[DeviceNumber]->DeviceFlags & DFLAGS_ATAPI_CHANGER)) {
        KdPrint3(("  Select %d\n", DeviceNumber));
    }
*/
    if(chan->last_devsel == DeviceNumber) {
        //KdPrint3(("  Selected %d\n", DeviceNumber));
        return 1;
    }
    AtapiWritePort1(chan, IDX_IO1_o_DriveSelect, DeviceNumber ? IDE_DRIVE_SELECT_2 : IDE_DRIVE_SELECT_1); \
    chan->last_devsel = DeviceNumber ? 1 : 0;
    if(!g_opt_DriveSelectNanoDelay) {
        //KdPrint3(("  Select %d\n", DeviceNumber));
        return 2;
    }
    //KdPrint3(("  Select %d (%d ns)\n", DeviceNumber, g_opt_DriveSelectNanoDelay));
    UniataNanoSleep(g_opt_DriveSelectNanoDelay);
    return 2;
} // end SelectDrive()
 
UCHAR
DDKFASTAPI
WaitOnBusy(
    IN PHW_CHANNEL   chan
    )
{
    ULONG i;
    UCHAR Status;
 
    GetStatus(chan, Status);
    for (i=0; i<g_opt_WaitBusyCount; i++) {
        if (Status & IDE_STATUS_BUSY) {
            AtapiStallExecution(g_opt_WaitBusyDelay);
            GetStatus(chan, Status);
            continue;
        } else {
            break;
        }
    }
    return Status;
} // end WaitOnBusy()
 
UCHAR
DDKFASTAPI
WaitOnBusyLong(
    IN PHW_CHANNEL   chan
    )
{
    ULONG i;
    UCHAR Status;
 
    Status = WaitOnBusy(chan);
    if(!(Status & IDE_STATUS_BUSY))
        return Status;
    for (i=0; i<g_opt_WaitBusyLongCount; i++) {
        GetStatus(chan, Status);
        if (Status & IDE_STATUS_BUSY) {
            AtapiStallExecution(g_opt_WaitBusyLongDelay);
            continue;
        } else {
            break;
        }
    }
    return Status;
} // end WaitOnBusyLong()
 
UCHAR
DDKFASTAPI
WaitOnBaseBusy(
    IN PHW_CHANNEL   chan
    )
{
    ULONG i;
    UCHAR Status = IDE_STATUS_WRONG;
    for (i=0; i<g_opt_WaitBusyCount; i++) {
        GetBaseStatus(chan, Status);
        if (Status & IDE_STATUS_BUSY) {
            AtapiStallExecution(g_opt_WaitBusyDelay);
            continue;
        } else {
            break;
        }
    }
    return Status;
} // end WaitOnBaseBusy()
 
UCHAR
DDKFASTAPI
WaitOnBaseBusyLong(
    IN PHW_CHANNEL   chan
    )
{
    ULONG i;
    UCHAR Status;
 
    Status = WaitOnBaseBusy(chan);
    if(!(Status & IDE_STATUS_BUSY))
        return Status;
    for (i=0; i<2000; i++) {
        GetBaseStatus(chan, Status);
        if (Status & IDE_STATUS_BUSY) {
            AtapiStallExecution(250);
            continue;
        } else {
            break;
        }
    }
    return Status;
} // end WaitOnBaseBusyLong()
 
UCHAR
DDKFASTAPI
UniataIsIdle(
    IN struct _HW_DEVICE_EXTENSION* deviceExtension,
    IN UCHAR Status
    )
{
    UCHAR Status2;
 
    if(Status == IDE_STATUS_WRONG) {
        return IDE_STATUS_WRONG;
    }
    if(Status & IDE_STATUS_BUSY) {
        return Status;
    }
//    if(deviceExtension->HwFlags & UNIATA_SATA) {
    if(UniataIsSATARangeAvailable(deviceExtension, 0)) {
        if(Status & (IDE_STATUS_BUSY | IDE_STATUS_ERROR)) {
            return Status;
        }
    } else {
        Status2 = Status & ~(IDE_STATUS_ERROR | IDE_STATUS_INDEX);
        if ((Status & IDE_STATUS_BUSY) ||
            (Status2 != IDE_STATUS_IDLE && Status2 != IDE_STATUS_DRDY)) {
            return Status;
        }
    }
    return IDE_STATUS_IDLE;
} // end UniataIsIdle()
 
UCHAR
DDKFASTAPI
WaitForIdleLong(
    IN PHW_CHANNEL   chan
    )
{
    ULONG i;
    UCHAR Status;
    UCHAR Status2;
    for (i=0; i<20000; i++) {
        GetStatus(chan, Status);
        Status2 = UniataIsIdle(chan->DeviceExtension, Status);
        if(Status2 == IDE_STATUS_WRONG) {
            // no drive ?
            break;
        } else
        if(Status2 & IDE_STATUS_BUSY) {
            AtapiStallExecution(10);
            continue;
        } else {
            break;
        }
    }
    return Status;
} // end WaitForIdleLong()
 
UCHAR
DDKFASTAPI
WaitForDrq(
    IN PHW_CHANNEL   chan
    )
{
    ULONG i;
    UCHAR Status;
    for (i=0; i<1000; i++) {
        GetStatus(chan, Status);
        if (Status & IDE_STATUS_BUSY) {
            AtapiStallExecution(g_opt_WaitDrqDelay);
        } else if (Status & IDE_STATUS_DRQ) {
            break;
        } else {
            AtapiStallExecution(g_opt_WaitDrqDelay*2);
        }
    }
    return Status;
} // end WaitForDrq()
 
UCHAR
DDKFASTAPI
WaitShortForDrq(
    IN PHW_CHANNEL   chan
    )
{
    ULONG i;
    UCHAR Status;
    for (i=0; i<2; i++) {
        GetStatus(chan, Status);
        if (Status & IDE_STATUS_BUSY) {
            AtapiStallExecution(g_opt_WaitDrqDelay);
        } else if (Status & IDE_STATUS_DRQ) {
            break;
        } else {
            AtapiStallExecution(g_opt_WaitDrqDelay);
        }
    }
    return Status;
} // end WaitShortForDrq()
 
VOID
DDKFASTAPI
AtapiSoftReset(
    IN PHW_CHANNEL   chan,
    IN ULONG         DeviceNumber
    )
{
    //ULONG c = chan->lChannel;
    ULONG i = 30 * 1000;
    UCHAR dma_status = 0;
    KdPrint2((PRINT_PREFIX "AtapiSoftReset:\n"));
    UCHAR statusByte0, statusByte2;
 
    if(chan->DeviceExtension->HwFlags & UNIATA_AHCI) {
        UniataAhciSoftReset(chan->DeviceExtension, chan->lChannel, DeviceNumber);
        return;
    }
 
    GetBaseStatus(chan, statusByte2);
    KdPrint2((PRINT_PREFIX "  statusByte2 %x:\n", statusByte2));
    SelectDrive(chan, DeviceNumber);
    if(chan->lun[DeviceNumber]->DeviceFlags & DFLAGS_MANUAL_CHS) {
        // For ESDI/MFM
        KdPrint2((PRINT_PREFIX "  ESDI/MFM\n"));
        AtapiStallExecution(10000);
        for (i = 0; i < 1000; i++) {
            AtapiStallExecution(999);
        }
/*    } else
    // Seems to be unnecessary, verified by KtP
    if(!hasPCI) {
        // original atapi.sys behavior for old ISA-only hardware
        AtapiStallExecution(10000);
        AtapiWritePort1(chan, IDX_IO1_o_Command, IDE_COMMAND_ATAPI_RESET);
        for (i = 0; i < 1000; i++) {
            AtapiStallExecution(999);
        } */
    } else {
        AtapiStallExecution(500);
        GetBaseStatus(chan, statusByte2);
        statusByte0 = statusByte2;
        AtapiWritePort1(chan, IDX_IO1_o_Command, IDE_COMMAND_ATAPI_RESET);
 
        // Do not wait for BUSY assertion if it was initially set, jump to
        // BUSY release wait loop
        if(!(statusByte0 & IDE_STATUS_BUSY)) {
            // Wait for BUSY assertion, in some cases delay may occure
            // 100ms should be enough
            if(g_opt_VirtualMachine == VM_BOCHS) {
                i = 100;
            } else {
                i = 10*1000;
            }
            statusByte2 = AtapiReadPort1(chan, IDX_IO1_i_Status);
            while (!(statusByte2 & IDE_STATUS_BUSY) &&
                   i--)
            {
                if(!(statusByte0 & IDE_STATUS_ERROR) && (statusByte2 & IDE_STATUS_ERROR)) {
                    KdPrint2((PRINT_PREFIX "  Command aborted, statusByte2 %x:\n", statusByte2));
                    break;
                }
                AtapiStallExecution(10);
            }
        }
 
        i = 30 * 1000;
        // ReactOS modification: Already stop looping when we know that the drive has finished resetting.
        // Not all controllers clear the IDE_STATUS_BUSY flag (e.g. not the VMware one), so ensure that
        // the maximum waiting time (30 * i = 0.9 seconds) does not exceed the one of the original
        // implementation. (which is around 1 second)
        while ((AtapiReadPort1(chan, IDX_IO1_i_Status) & IDE_STATUS_BUSY) &&
               i--)
        {
            AtapiStallExecution(30);
        }
        KdPrint2((PRINT_PREFIX " set DFLAGS_REINIT_DMA\n"));
        chan->lun[DeviceNumber]->DeviceFlags |= DFLAGS_REINIT_DMA;
    }
 
    chan->last_devsel = -1; // make sure proper drive would be selected
    SelectDrive(chan, DeviceNumber);
    WaitOnBusy(chan);
    GetBaseStatus(chan, statusByte2);
    AtapiStallExecution(500);
 
    GetBaseStatus(chan, statusByte2);
    if(chan && chan->DeviceExtension) {
        dma_status = GetDmaStatus(chan->DeviceExtension, chan->lChannel);
        KdPrint2((PRINT_PREFIX "  DMA status %#x\n", dma_status));
    } else {
        KdPrint2((PRINT_PREFIX "  can't get DMA status\n"));
    }
    if(dma_status & BM_STATUS_INTR) {
        // bullshit, we have DMA interrupt, but had never initiate DMA operation
        KdPrint2((PRINT_PREFIX "  clear unexpected DMA intr on ATAPI reset\n"));
        AtapiDmaDone(chan->DeviceExtension, DeviceNumber, chan->lChannel, NULL);
        GetBaseStatus(chan, statusByte2);
    }
    if(chan->DeviceExtension->HwFlags & UNIATA_SATA) {
        UniataSataClearErr(chan->DeviceExtension, chan->lChannel, UNIATA_SATA_IGNORE_CONNECT, DeviceNumber);
/*        if(!(chan->ChannelCtrlFlags & CTRFLAGS_NO_SLAVE)) {
            UniataSataClearErr(chan->DeviceExtension, chan->lChannel, UNIATA_SATA_IGNORE_CONNECT, 1);
        }*/
    }
    return;
 
} // end AtapiSoftReset()
 
VOID
DDKFASTAPI
AtapiHardReset(
    IN struct _HW_CHANNEL*   chan,
    IN BOOLEAN               DisableInterrupts,
    IN ULONG                 Delay
    )
{
    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()
 
/*
    Send command to device.
    Translate to 48-Lba form if required
*/
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
    )
{
    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()
 
/*
    Send command to device.
    This is simply wrapper for AtaCommand48()
*/
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
    )
{
    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()
 
LONG
NTAPI
AtaPio2Mode(LONG pio)
{
    switch (pio) {
    default: return ATA_PIO;
    case 0: return ATA_PIO0;
    case 1: return ATA_PIO1;
    case 2: return ATA_PIO2;
    case 3: return ATA_PIO3;
    case 4: return ATA_PIO4;
    case 5: return ATA_PIO5;
    }
} // end AtaPio2Mode()
 
LONG
NTAPI
AtaPioMode(PIDENTIFY_DATA2 ident)
{
    if (ident->PioTimingsValid) {
        if (ident->AdvancedPIOModes & AdvancedPIOModes_5)
            return 5;
        if (ident->AdvancedPIOModes & AdvancedPIOModes_4)
            return 4;
        if (ident->AdvancedPIOModes & AdvancedPIOModes_3)
            return 3;
    }
    if (ident->PioCycleTimingMode == 2)
        return 2;
    if (ident->PioCycleTimingMode == 1)
        return 1;
    if (ident->PioCycleTimingMode == 0)
        return 0;
    return IOMODE_NOT_SPECIFIED;
} // end AtaPioMode()
 
LONG
NTAPI
AtaWmode(PIDENTIFY_DATA2 ident)
{
    if (ident->MultiWordDMASupport & 0x04)
        return 2;
    if (ident->MultiWordDMASupport & 0x02)
        return 1;
    if (ident->MultiWordDMASupport & 0x01)
        return 0;
    return IOMODE_NOT_SPECIFIED;
} // end AtaWmode()
 
LONG
NTAPI
AtaUmode(PIDENTIFY_DATA2 ident)
{
    if (!ident->UdmaModesValid)
        return IOMODE_NOT_SPECIFIED;
    if (ident->UltraDMASupport & 0x40)
        return 6;
    if (ident->UltraDMASupport & 0x20)
        return 5;
    if (ident->UltraDMASupport & 0x10)
        return 4;
    if (ident->UltraDMASupport & 0x08)
        return 3;
    if (ident->UltraDMASupport & 0x04)
        return 2;
    if (ident->UltraDMASupport & 0x02)
        return 1;
    if (ident->UltraDMASupport & 0x01)
        return 0;
    return IOMODE_NOT_SPECIFIED;
} // end AtaUmode()
 
LONG
NTAPI
AtaSAmode(PIDENTIFY_DATA2 ident) {
    if(!ident->SataCapabilities ||
       ident->SataCapabilities == 0xffff) {
        return IOMODE_NOT_SPECIFIED;
    }
    if(ident->SataCapabilities & ATA_SATA_GEN3) {
        return ATA_SA600;
    } else
    if(ident->SataCapabilities & ATA_SATA_GEN2) {
        return ATA_SA300;
    } else
    if(ident->SataCapabilities & ATA_SATA_GEN1) {
        return ATA_SA150;
    }
    return IOMODE_NOT_SPECIFIED;
} // end AtaSAmode()
 
#ifndef UNIATA_CORE
 
VOID
NTAPI
AtapiTimerDpc(
    IN PVOID HwDeviceExtension
    )
{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PHW_TIMER HwScsiTimer;
    LARGE_INTEGER time;
    ULONG MiniportTimerValue;
    BOOLEAN recall = FALSE;
    ULONG lChannel;
    PHW_CHANNEL chan;
 
    KdPrint2((PRINT_PREFIX "AtapiTimerDpc:\n"));
 
    lChannel = deviceExtension->ActiveDpcChan = deviceExtension->FirstDpcChan;
    if(lChannel == CHAN_NOT_SPECIFIED) {
        KdPrint2((PRINT_PREFIX "AtapiTimerDpc: no items\n"));
        return;
    }
    chan = &(deviceExtension->chan[lChannel]);
 
    while(TRUE) {
 
        HwScsiTimer = chan->HwScsiTimer;
        chan->HwScsiTimer = NULL;
 
        deviceExtension->FirstDpcChan = chan->NextDpcChan;
        if(deviceExtension->FirstDpcChan != CHAN_NOT_SPECIFIED) {
            recall = TRUE;
        }
 
        HwScsiTimer(HwDeviceExtension);
 
        chan->NextDpcChan = CHAN_NOT_SPECIFIED;
 
        lChannel = deviceExtension->ActiveDpcChan = deviceExtension->FirstDpcChan;
        if(lChannel == CHAN_NOT_SPECIFIED) {
            KdPrint2((PRINT_PREFIX "AtapiTimerDpc: no more items\n"));
            deviceExtension->FirstDpcChan =
            deviceExtension->ActiveDpcChan = CHAN_NOT_SPECIFIED;
            return;
        }
 
        KeQuerySystemTime(&time);
        KdPrint2((PRINT_PREFIX "AtapiTimerDpc: KeQuerySystemTime=%#x%#x\n", time.HighPart, time.LowPart));
 
        chan = &deviceExtension->chan[lChannel];
        if(time.QuadPart >= chan->DpcTime - 10) {
            // call now
            KdPrint2((PRINT_PREFIX "AtapiTimerDpc: get next DPC, DpcTime1=%#x%#x\n",
                         (ULONG)(chan->DpcTime >> 32), (ULONG)(chan->DpcTime)));
            continue;
        }
        break;
    }
 
    if(recall) {
        deviceExtension->ActiveDpcChan = CHAN_NOT_SPECIFIED;
        MiniportTimerValue = (ULONG)(time.QuadPart - chan->DpcTime)/10;
        if(!MiniportTimerValue)
            MiniportTimerValue = 1;
 
        KdPrint2((PRINT_PREFIX "AtapiTimerDpc: recall AtapiTimerDpc\n"));
        ScsiPortNotification(RequestTimerCall, HwDeviceExtension,
                             AtapiTimerDpc,
                             MiniportTimerValue
                             );
    }
    return;
 
} // end AtapiTimerDpc()
 
/*
    Wrapper for ScsiPort, that implements smart Dpc
    queueing. We need it to allow parallel functioning
    of IDE channels with shared interrupt. Standard Dpc mechanism
    cancels previous Dpc request (if any), but we need Dpc queue.
*/
VOID
NTAPI
AtapiQueueTimerDpc(
    IN PVOID HwDeviceExtension,
    IN ULONG lChannel,
    IN PHW_TIMER HwScsiTimer,
    IN ULONG MiniportTimerValue
    )
{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    LARGE_INTEGER time;
    LARGE_INTEGER time2;
    ULONG i;
    PHW_CHANNEL prev_chan;
    PHW_CHANNEL chan;
//    BOOLEAN UseRequestTimerCall = TRUE;
 
    KdPrint2((PRINT_PREFIX "AtapiQueueTimerDpc: dt=%d for lChn %#x\n", MiniportTimerValue, lChannel));
    KeQuerySystemTime(&time);
    time2 = time;
    KdPrint2((PRINT_PREFIX "AtapiQueueTimerDpc: KeQuerySystemTime=%#x%#x\n", time.HighPart, time.LowPart));
    time.QuadPart += MiniportTimerValue*10;
    KdPrint2((PRINT_PREFIX "AtapiQueueTimerDpc: KeQuerySystemTime2=%#x%#x\n", time.HighPart, time.LowPart));
 
    KdPrint2((PRINT_PREFIX "  ActiveDpcChan=%d, FirstDpcChan=%d\n", deviceExtension->ActiveDpcChan, deviceExtension->FirstDpcChan));
 
    i = deviceExtension->FirstDpcChan;
    chan = prev_chan = NULL;
    while(i != CHAN_NOT_SPECIFIED) {
        prev_chan = chan;
        chan = &(deviceExtension->chan[i]);
        if(chan->DpcTime > time.QuadPart) {
            break;
        }
        i = chan->NextDpcChan;
    }
    chan = &(deviceExtension->chan[lChannel]);
    if(!prev_chan) {
        deviceExtension->FirstDpcChan = lChannel;
    } else {
        prev_chan->NextDpcChan = lChannel;
    }
    chan->NextDpcChan = i;
    chan->HwScsiTimer = HwScsiTimer;
    chan->DpcTime     = time.QuadPart;
 
    KdPrint2((PRINT_PREFIX "AtapiQueueTimerDpc: KeQuerySystemTime3=%#x%#x\n", time2.HighPart, time2.LowPart));
    if(time.QuadPart <= time2.QuadPart) {
        MiniportTimerValue = 1;
    } else {
        MiniportTimerValue = (ULONG)((time.QuadPart - time2.QuadPart) / 10);
    }
 
    KdPrint2((PRINT_PREFIX "AtapiQueueTimerDpc: dt=%d for lChn %#x\n", MiniportTimerValue, lChannel));
    ScsiPortNotification(RequestTimerCall, HwDeviceExtension,
                         AtapiTimerDpc,
                         MiniportTimerValue);
 
} // end AtapiQueueTimerDpc()
 
#endif //UNIATA_CORE
 
#ifdef _DEBUG
VOID
NTAPI
UniataDumpATARegs(
    IN PHW_CHANNEL chan
    )
{
    ULONG                j;
    UCHAR                statusByteAlt;
 
    GetStatus(chan, statusByteAlt);
    KdPrint2((PRINT_PREFIX "  AltStatus (%#x)\n", statusByteAlt));
 
    for(j=1; j<IDX_IO1_SZ; j++) {
        statusByteAlt = AtapiReadPort1(chan, IDX_IO1+j);
        KdPrint2((PRINT_PREFIX
                   "  Reg_%#x (%#x) = %#x\n",
                   j,
                   chan->RegTranslation[IDX_IO1+j].Addr,
                   statusByteAlt));
    }
    if(!chan->RegTranslation[IDX_BM_IO].Addr) {
        return;
    }
    for(j=0; j<IDX_BM_IO_SZ-1; j++) {
        statusByteAlt = AtapiReadPort1(chan, IDX_BM_IO+j);
        KdPrint2((PRINT_PREFIX
                   "  BM_%#x (%#x) = %#x\n",
                   j,
                   chan->RegTranslation[IDX_BM_IO+j].Addr,
                   statusByteAlt));
    }
    return;
} // end UniataDumpATARegs()
#endif //_DEBUG
 
VOID
NTAPI
UniataSnapAtaRegs(
    IN PHW_CHANNEL chan,
    IN ULONG DeviceNumber,
 IN OUT PIDEREGS_EX regs
    )
{
    if(chan->DeviceExtension->HwFlags & UNIATA_AHCI) {
        // AHCI
        UniataAhciSnapAtaRegs(chan, DeviceNumber, regs);
    } else {
        // SATA/PATA, assume drive is selected
        ULONG                j;
        UCHAR                statusByteAlt;
 
        if((regs->bOpFlags & ATA_FLAGS_48BIT_COMMAND) == 0) {
            for(j=IDX_IO1_i_Error; j<=IDX_IO1_i_Status; j++) {
                statusByteAlt = AtapiReadPort1(chan, IDX_IO1+j);
                ((PUCHAR)regs)[j-1] = statusByteAlt;
            }
            regs->bOpFlags = 0;
        } else {
            regs->bDriveHeadReg    = AtapiReadPort1(chan, IDX_IO1_i_DriveSelect);
            for(j=IDX_IO1_i_Error; j<IDX_IO1_i_DriveSelect; j++) {
                statusByteAlt = AtapiReadPort1(chan, IDX_IO1+j);
                ((PUCHAR)regs)[j-1] = statusByteAlt;
                statusByteAlt = AtapiReadPort1(chan, IDX_IO1+j);
                ((PUCHAR)regs)[j+8-1] = statusByteAlt;
            }
            regs->bCommandReg      = AtapiReadPort1(chan, IDX_IO1_i_Status);
        }
    }
    return;
} // end UniataSnapAtaRegs()
 
/*++
 
Routine Description:
 
    Issue IDENTIFY command to a device.
 
Arguments:
 
    HwDeviceExtension - HBA miniport driver's adapter data storage
    DeviceNumber - Indicates which device.
    Command - Either the standard (EC) or the ATAPI packet (A1) IDENTIFY.
 
Return Value:
 
    TRUE if all goes well.
 
--*/
BOOLEAN
NTAPI
IssueIdentify(
    IN PVOID HwDeviceExtension,
    IN ULONG DeviceNumber,
    IN ULONG lChannel,
    IN UCHAR Command,
    IN BOOLEAN NoSetup
    )
{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PHW_CHANNEL          chan = &(deviceExtension->chan[lChannel]);
    ULONG                waitCount = 50000;
    ULONG                j;
    UCHAR                statusByte;
    //UCHAR                statusByte2;
    UCHAR                signatureLow,
                         signatureHigh;
    BOOLEAN              atapiDev = FALSE;
    BOOLEAN              use_ahci = FALSE;
    PHW_LU_EXTENSION     LunExt = chan->lun[DeviceNumber];
 
    use_ahci = UniataIsSATARangeAvailable(deviceExtension, lChannel) &&
        (deviceExtension->HwFlags & UNIATA_AHCI);
 
    if(chan->ChannelCtrlFlags & CTRFLAGS_AHCI_PM) {
        if(chan->PmLunMap & (1 << DeviceNumber)) {
            // OK
        } else {
            KdPrint2((PRINT_PREFIX "IssueIdentify: PM empty port\n"));
            return FALSE;
        }
    } else
    if(DeviceNumber && (chan->ChannelCtrlFlags & CTRFLAGS_NO_SLAVE)) {
        KdPrint2((PRINT_PREFIX "IssueIdentify: NO SLAVE\n"));
        return FALSE;
    }
    if(LunExt->DeviceFlags & DFLAGS_HIDDEN) {
        KdPrint2((PRINT_PREFIX "IssueIdentify: HIDDEN\n"));
        return FALSE;
    }
 
    if(use_ahci) {
        statusByte = WaitOnBusyLong(chan);
#ifdef _DEBUG
        if(!chan->AhciInternalAtaReq) {
            KdPrint2((PRINT_PREFIX "!AhciInternalAtaReq\n"));
        }
#endif
    } else {
        SelectDrive(chan, DeviceNumber);
        AtapiStallExecution(10);
        statusByte = WaitOnBusyLong(chan);
        // Check that the status register makes sense.
        GetBaseStatus(chan, statusByte);
        /*
        // unnecessary
        if(!hasPCI) {
            // original atapi.sys behavior for old ISA-only hardware
            AtapiStallExecution(100);
        }
        */
    }
 
    if (Command == IDE_COMMAND_IDENTIFY) {
        // Mask status byte ERROR bits.
        statusByte = UniataIsIdle(deviceExtension, statusByte & ~(IDE_STATUS_ERROR | IDE_STATUS_INDEX));
        KdPrint2((PRINT_PREFIX "IssueIdentify: Checking for IDE. Status (%#x)\n", statusByte));
        // Check if register value is reasonable.
 
        if(statusByte != IDE_STATUS_IDLE) {
 
            // No reset here !!!
            KdPrint2((PRINT_PREFIX "IssueIdentify: statusByte != IDE_STATUS_IDLE\n"));
 
            //if(!(deviceExtension->HwFlags & UNIATA_SATA)) {
            if(!UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
                SelectDrive(chan, DeviceNumber);
                WaitOnBusyLong(chan);
 
                signatureLow = AtapiReadPort1(chan, IDX_IO1_i_CylinderLow);
                signatureHigh = AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh);
 
                if (signatureLow == ATAPI_MAGIC_LSB &&
                    signatureHigh == ATAPI_MAGIC_MSB) {
                    // Device is Atapi.
                    KdPrint2((PRINT_PREFIX "IssueIdentify: this is ATAPI (dev %d)\n", DeviceNumber));
                    return FALSE;
                }
 
                // We really should wait up to 31 seconds
                // The ATA spec. allows device 0 to come back from BUSY in 31 seconds!
                // (30 seconds for device 1)
                do {
                    // Wait for Busy to drop.
                    AtapiStallExecution(100);
                    GetStatus(chan, statusByte);
                    if(statusByte == IDE_STATUS_WRONG) {
                        KdPrint2((PRINT_PREFIX "IssueIdentify: IDE_STATUS_WRONG (dev %d)\n", DeviceNumber));
                        return FALSE;
                    }
 
                } while ((statusByte & IDE_STATUS_BUSY) && waitCount--);
                GetBaseStatus(chan, statusByte);
 
                SelectDrive(chan, DeviceNumber);
            } else {
                GetBaseStatus(chan, statusByte);
            }
            // Another check for signature, to deal with one model Atapi that doesn't assert signature after
            // a soft reset.
            signatureLow = AtapiReadPort1(chan, IDX_IO1_i_CylinderLow);
            signatureHigh = AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh);
 
            if (signatureLow == ATAPI_MAGIC_LSB &&
                signatureHigh == ATAPI_MAGIC_MSB) {
                KdPrint2((PRINT_PREFIX "IssueIdentify: this is ATAPI (2) (dev %d)\n", DeviceNumber));
                // Device is Atapi.
                return FALSE;
            }
 
            statusByte = UniataIsIdle(deviceExtension, statusByte) & ~IDE_STATUS_INDEX;
            if (statusByte != IDE_STATUS_IDLE) {
                // Give up on this.
                KdPrint2((PRINT_PREFIX "IssueIdentify: no dev (dev %d)\n", DeviceNumber));
                return FALSE;
            }
        }
    } else {
        KdPrint2((PRINT_PREFIX "IssueIdentify: Checking for ATAPI. Status (%#x)\n", statusByte));
        if(statusByte == IDE_STATUS_WRONG) {
            return FALSE;
        }
        //if(!(deviceExtension->HwFlags & UNIATA_SATA)) {
        if(!UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
            statusByte = WaitForIdleLong(chan);
            KdPrint2((PRINT_PREFIX "IssueIdentify: Checking for ATAPI (2). Status (%#x)\n", statusByte));
        }
        atapiDev = TRUE;
    }
 
//    if(deviceExtension->HwFlags & UNIATA_SATA) {
    if(use_ahci) {
        statusByte = UniataAhciSendPIOCommand(HwDeviceExtension, lChannel, DeviceNumber,
            (PSCSI_REQUEST_BLOCK)NULL,
            (PUCHAR)(&deviceExtension->FullIdentifyData),
            DEV_BSIZE,
            Command,
            0, 0,
            0,
            0 /* ahci flags */ ,
            ATA_WAIT_INTR,
            1000 /* timeout 1 sec */
            );
        j = 9; // AHCI is rather different, skip loop at all
    } else
    if(LunExt->DeviceFlags & DFLAGS_MANUAL_CHS) {
        j = 9; // don't send IDENTIFY, assume it is not supported
        KdPrint2((PRINT_PREFIX "IssueIdentify: Manual CHS\n"));
        RtlZeroMemory(&(deviceExtension->FullIdentifyData), sizeof(deviceExtension->FullIdentifyData));
        RtlCopyMemory(&(deviceExtension->FullIdentifyData), &(LunExt->IdentifyData), sizeof(LunExt->IdentifyData));
    } else
    if(UniataIsSATARangeAvailable(deviceExtension, lChannel)) {
        j = 4; // skip old-style checks
    } else {
        j = 0;
    }
    for (; j < 4*2; j++) {
        // Send IDENTIFY command.
 
        // Load CylinderHigh and CylinderLow with number bytes to transfer for old devices, use 0 for newer.
 
        statusByte = AtaCommand(deviceExtension, DeviceNumber, lChannel, Command, (j < 4) ? DEV_BSIZE : 0 /* cyl */, 0, 0, 0, 0, ATA_WAIT_INTR);
        // Clear interrupt
 
        if (!statusByte) {
            KdPrint2((PRINT_PREFIX "IssueIdentify: 0-status, not present\n"));
            return FALSE;
        } else
        if (statusByte & IDE_STATUS_DRQ) {
            // Read status to acknowledge any interrupts generated.
            KdPrint2((PRINT_PREFIX "IssueIdentify: IDE_STATUS_DRQ (%#x)\n", statusByte));
            GetBaseStatus(chan, statusByte);
            // One last check for Atapi.
            if (Command == IDE_COMMAND_IDENTIFY) {
                signatureLow = AtapiReadPort1(chan, IDX_IO1_i_CylinderLow);
                signatureHigh = AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh);
 
                if (signatureLow == ATAPI_MAGIC_LSB &&
                    signatureHigh == ATAPI_MAGIC_MSB) {
                    KdPrint2((PRINT_PREFIX "IssueIdentify: this is ATAPI (3) (dev %d)\n", DeviceNumber));
                    // Device is Atapi.
                    return FALSE;
                }
            }
            break;
        } else {
            KdPrint2((PRINT_PREFIX "IssueIdentify: !IDE_STATUS_DRQ (%#x)\n", statusByte));
            if (Command == IDE_COMMAND_IDENTIFY) {
                // Check the signature. If DRQ didn't come up it's likely Atapi.
                signatureLow = AtapiReadPort1(chan, IDX_IO1_i_CylinderLow);
                signatureHigh = AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh);
 
                if (signatureLow == ATAPI_MAGIC_LSB &&
                    signatureHigh == ATAPI_MAGIC_MSB) {
                    // Device is Atapi.
                    KdPrint2((PRINT_PREFIX "IssueIdentify: this is ATAPI (4) (dev %d)\n", DeviceNumber));
                    return FALSE;
                }
            } else {
                if(!(statusByte & IDE_STATUS_ERROR) && (statusByte & IDE_STATUS_BUSY)) {
                    KdPrint2((PRINT_PREFIX "IssueIdentify: DRQ not asserted immediately, BUSY -> WaitForDrq\n"));
                    break;
                }
            }
            // Device didn't respond correctly. It will be given one more chance.
            KdPrint2((PRINT_PREFIX "IssueIdentify: DRQ never asserted (%#x). Error reg (%#x)\n",
                        statusByte, AtapiReadPort1(chan, IDX_IO1_i_Error)));
            GetBaseStatus(chan, statusByte);
            AtapiSoftReset(chan,DeviceNumber);
 
            AtapiDisableInterrupts(deviceExtension, lChannel);
            AtapiEnableInterrupts(deviceExtension, lChannel);
 
            GetBaseStatus(chan, statusByte);
            //GetStatus(chan, statusByte);
            KdPrint2((PRINT_PREFIX "IssueIdentify: Status after soft reset (%#x)\n", statusByte));
        }
    }
    // Check for error on really stupid master devices that assert random
    // patterns of bits in the status register at the slave address.
    if ((Command == IDE_COMMAND_IDENTIFY) && (statusByte & IDE_STATUS_ERROR)) {
        KdPrint2((PRINT_PREFIX "IssueIdentify: Exit on error (%#x)\n", statusByte));
        return FALSE;
    }
 
    if(use_ahci) {
        // everything should already be done by controller
    } else
    if(LunExt->DeviceFlags & DFLAGS_MANUAL_CHS) {
        j = 9; // don't send IDENTIFY, assume it is not supported
        KdPrint2((PRINT_PREFIX "IssueIdentify: Manual CHS (2)\n"));
        statusByte = WaitForDrq(chan);
        statusByte = WaitOnBusyLong(chan);
            KdPrint2((PRINT_PREFIX "IssueIdentify: statusByte %#x\n", statusByte));
        GetBaseStatus(chan, statusByte);
    } else {
 
        KdPrint2((PRINT_PREFIX "IssueIdentify: Status before read words %#x\n", statusByte));
        // Suck out 256 words. After waiting for one model that asserts busy
        // after receiving the Packet Identify command.
        statusByte = WaitForDrq(chan);
        statusByte = WaitOnBusyLong(chan);
            KdPrint2((PRINT_PREFIX "IssueIdentify: statusByte %#x\n", statusByte));
 
        if (!(statusByte & IDE_STATUS_DRQ)) {
            KdPrint2((PRINT_PREFIX "IssueIdentify: !IDE_STATUS_DRQ (2) (%#x)\n", statusByte));
            GetBaseStatus(chan, statusByte);
            return FALSE;
        }
        GetBaseStatus(chan, statusByte);
        KdPrint2((PRINT_PREFIX "IssueIdentify: BASE statusByte %#x\n", statusByte));
 
#ifdef _DEBUG
        if(atapiDev) {
          j = (AtapiReadPort1(chan, IDX_ATAPI_IO1_i_InterruptReason) & ATAPI_IR_Mask);
          KdPrint3((PRINT_PREFIX "IssueIdentify: iReason %x\n", j));
 
          j =
              AtapiReadPort1(chan, IDX_ATAPI_IO1_i_ByteCountLow);
 
          j |=
              (USHORT)AtapiReadPort1(chan, IDX_ATAPI_IO1_i_ByteCountHigh) << 8;
          KdPrint3((PRINT_PREFIX "IssueIdentify: wCount %x\n", j));
 
        }
#endif //_DEBUG
 
        if (atapiDev || !(LunExt->DeviceFlags & DFLAGS_DWORDIO_ENABLED) ) {
 
            KdPrint2((PRINT_PREFIX "  use 16bit IO\n"));
            // ATI/SII chipsets with memory-mapped IO hangs when
            // I call ReadBuffer(), probably due to PCI burst/prefetch enabled
            // Unfortunately, I don't know yet how to workaround it except
            // spacifying manual delay in the way you see below.
            ReadBuffer(chan, (PUSHORT)&deviceExtension->FullIdentifyData, 256, PIO0_TIMING);
 
            // Work around for some IDE and one model Atapi that will present more than
            // 256 bytes for the Identify data.
            KdPrint2((PRINT_PREFIX "IssueIdentify: suck data port\n", statusByte));
            statusByte = AtapiSuckPort2(chan);
        } else {
            KdPrint2((PRINT_PREFIX "  use 32bit IO\n"));
            ReadBuffer2(chan, (PULONG)&deviceExtension->FullIdentifyData, 256/2, PIO0_TIMING);
        }
 
        KdPrint2((PRINT_PREFIX "IssueIdentify: statusByte %#x\n", statusByte));
        statusByte = WaitForDrq(chan);
        KdPrint2((PRINT_PREFIX "IssueIdentify: statusByte %#x\n", statusByte));
        GetBaseStatus(chan, statusByte);
    }
    KdPrint2((PRINT_PREFIX "IssueIdentify: Status after read words %#x\n", statusByte));
 
    if(NoSetup) {
        KdPrint2((PRINT_PREFIX "IssueIdentify: no setup, exiting\n"));
        return TRUE;
    }
 
    KdPrint2((PRINT_PREFIX "Model: %20.20s\n", deviceExtension->FullIdentifyData.ModelNumber));
    KdPrint2((PRINT_PREFIX "FW:    %4.4s\n", deviceExtension->FullIdentifyData.FirmwareRevision));
    KdPrint2((PRINT_PREFIX "S/N:   %20.20s\n", deviceExtension->FullIdentifyData.SerialNumber));
    if(g_opt_VirtualMachine == VM_AUTO) {
        if((deviceExtension->FullIdentifyData.FirmwareRevision[0] == 0 ||
           deviceExtension->FullIdentifyData.FirmwareRevision[0] == ' ') &&
           (deviceExtension->FullIdentifyData.FirmwareRevision[1] == 0 ||
           deviceExtension->FullIdentifyData.FirmwareRevision[1] == ' ')) {
            // Check for BOCHS VM signature. If no additional PCI devices (e.g. VGA)
            // are declared BOCHS looks like regular PC
            if (!atapiDev && !AtapiStringCmp ((PCCHAR)(deviceExtension->FullIdentifyData.SerialNumber), "XBDH00", 6)) {
                KdPrint2((PRINT_PREFIX "IssueIdentify: BOCHS HDD\n"));
                g_opt_VirtualMachine = VM_BOCHS;
            } else
            if (atapiDev && !AtapiStringCmp ((PCCHAR)(deviceExtension->FullIdentifyData.SerialNumber), "XBDC00", 6)) {
                KdPrint2((PRINT_PREFIX "IssueIdentify: BOCHS CD\n"));
                g_opt_VirtualMachine = VM_BOCHS;
            }
        }
    }
 
    KdPrint2((PRINT_PREFIX "Pio:   %x\n", deviceExtension->FullIdentifyData.PioCycleTimingMode));
    if(deviceExtension->FullIdentifyData.PioTimingsValid) {
        KdPrint2((PRINT_PREFIX "APio:  %x\n", deviceExtension->FullIdentifyData.AdvancedPIOModes));
    }
    KdPrint2((PRINT_PREFIX "SWDMA: %x\n", deviceExtension->FullIdentifyData.SingleWordDMAActive));
    KdPrint2((PRINT_PREFIX "MWDMA: %x\n", deviceExtension->FullIdentifyData.MultiWordDMAActive));
    if(deviceExtension->FullIdentifyData.UdmaModesValid) {
        KdPrint2((PRINT_PREFIX "UDMA:  %x/%x\n", deviceExtension->FullIdentifyData.UltraDMAActive, deviceExtension->FullIdentifyData.UltraDMASupport));
    }
    KdPrint2((PRINT_PREFIX "SATA:  %x\n", deviceExtension->FullIdentifyData.SataEnable));
    KdPrint2((PRINT_PREFIX "SATA support: %x, CAPs %#x\n",
        deviceExtension->FullIdentifyData.SataSupport,
        deviceExtension->FullIdentifyData.SataCapabilities));
 
    LunExt->LimitedTransferMode =
    LunExt->OrigTransferMode =
        (UCHAR)ata_cur_mode_from_ident(&(deviceExtension->FullIdentifyData), IDENT_MODE_MAX);
    LunExt->TransferMode =
        (UCHAR)ata_cur_mode_from_ident(&(deviceExtension->FullIdentifyData), IDENT_MODE_ACTIVE);
 
    KdPrint2((PRINT_PREFIX "OrigTransferMode: %x, Active: %x\n", LunExt->OrigTransferMode, LunExt->TransferMode));
    KdPrint2((PRINT_PREFIX "Accoustic %d, cur %d\n",
        deviceExtension->FullIdentifyData.VendorAcoustic,
        deviceExtension->FullIdentifyData.CurrentAcoustic
        ));
    KdPrint2((PRINT_PREFIX "AdvPowerMode %d\n",
        deviceExtension->FullIdentifyData.CfAdvPowerMode
        ));
 
    KdPrint2((PRINT_PREFIX "PowerMngt %d/%d, APM %d/%d\n",
        deviceExtension->FullIdentifyData.FeaturesEnabled.PowerMngt,
        deviceExtension->FullIdentifyData.FeaturesSupport.PowerMngt,
        deviceExtension->FullIdentifyData.FeaturesEnabled.APM,
        deviceExtension->FullIdentifyData.FeaturesSupport.APM
        ));
 
    // Check out a few capabilities / limitations of the device.
    if (deviceExtension->FullIdentifyData.RemovableStatus & 1) {
        // Determine if this drive supports the MSN functions.
        KdPrint2((PRINT_PREFIX "IssueIdentify: Marking drive %d as removable. SFE = %d\n",
                    DeviceNumber,
                    deviceExtension->FullIdentifyData.RemovableStatus));
        LunExt->DeviceFlags |= DFLAGS_REMOVABLE_DRIVE;
    }
    if(use_ahci) {
        // AHCI doesn't recommend using PIO and multiblock
        LunExt->MaximumBlockXfer = 0;
    } else
    if (deviceExtension->FullIdentifyData.MaximumBlockTransfer) {
        // Determine max. block transfer for this device.
        LunExt->MaximumBlockXfer =
            (UCHAR)(deviceExtension->FullIdentifyData.MaximumBlockTransfer & 0xFF);
    }
    LunExt->NumOfSectors = 0;
    if (Command == IDE_COMMAND_IDENTIFY) {
        ULONGLONG NumOfSectors=0;
        ULONGLONG NativeNumOfSectors=0;
        ULONGLONG cylinders=0;
        ULONGLONG tmp_cylinders=0;
 
        KdPrint2((PRINT_PREFIX "PhysLogSectorSize %#x, %#x, offset %#x\n",
                deviceExtension->FullIdentifyData.PhysLogSectorSize,
                deviceExtension->FullIdentifyData.LargeSectorSize,
                deviceExtension->FullIdentifyData.LogicalSectorOffset
                ));
 
        KdPrint2((PRINT_PREFIX "NV PM_Sup %d, PM_En %d, En %d, PM ver %#x ver %#x\n",
                deviceExtension->FullIdentifyData.NVCache_PM_Supported,
                deviceExtension->FullIdentifyData.NVCache_PM_Enabled,
                deviceExtension->FullIdentifyData.NVCache_Enabled,
                deviceExtension->FullIdentifyData.NVCache_PM_Version,
                deviceExtension->FullIdentifyData.NVCache_Version
                ));
 
        KdPrint2((PRINT_PREFIX "R-rate %d\n",
                deviceExtension->FullIdentifyData.NominalMediaRotationRate
                ));
        KdPrint2((PRINT_PREFIX "WC %d/%d, LA %d/%d, WB %d/%d, RB %d/%d, Q %d/%d\n",
                deviceExtension->FullIdentifyData.FeaturesEnabled.WriteCache,
                deviceExtension->FullIdentifyData.FeaturesSupport.WriteCache,
                deviceExtension->FullIdentifyData.FeaturesEnabled.LookAhead,
                deviceExtension->FullIdentifyData.FeaturesSupport.LookAhead,
                deviceExtension->FullIdentifyData.FeaturesEnabled.WriteBuffer,
                deviceExtension->FullIdentifyData.FeaturesSupport.WriteBuffer,
                deviceExtension->FullIdentifyData.FeaturesEnabled.ReadBuffer,
                deviceExtension->FullIdentifyData.FeaturesSupport.ReadBuffer,
                deviceExtension->FullIdentifyData.FeaturesEnabled.Queued,
                deviceExtension->FullIdentifyData.FeaturesSupport.Queued
                ));
 
        KdPrint2((PRINT_PREFIX "Protected %d/%d status %#x, rev %#x\n",
                deviceExtension->FullIdentifyData.FeaturesEnabled.Protected,
                deviceExtension->FullIdentifyData.FeaturesSupport.Protected,
                deviceExtension->FullIdentifyData.SecurityStatus,
                deviceExtension->FullIdentifyData.MasterPasswdRevision
                ));
 
        // Read very-old-style drive geometry
        KdPrint2((PRINT_PREFIX "CHS %#x:%#x:%#x\n",
                deviceExtension->FullIdentifyData.NumberOfCylinders,
                deviceExtension->FullIdentifyData.NumberOfHeads,
                deviceExtension->FullIdentifyData.SectorsPerTrack
                ));
        NumOfSectors = deviceExtension->FullIdentifyData.NumberOfCylinders *
                       deviceExtension->FullIdentifyData.NumberOfHeads *
                       deviceExtension->FullIdentifyData.SectorsPerTrack;
        KdPrint2((PRINT_PREFIX "NumOfSectors %#I64x\n", NumOfSectors));
        // Check for HDDs > 8Gb
        if ((deviceExtension->FullIdentifyData.NumberOfCylinders == 0x3fff) &&
/*            (deviceExtension->FullIdentifyData.TranslationFieldsValid) &&*/
             deviceExtension->FullIdentifyData.NumberOfHeads &&
             deviceExtension->FullIdentifyData.SectorsPerTrack &&
            (NumOfSectors < deviceExtension->FullIdentifyData.UserAddressableSectors)) {
            KdPrint2((PRINT_PREFIX "NumberOfCylinders == 0x3fff\n"));
            cylinders =
                (deviceExtension->FullIdentifyData.UserAddressableSectors /
                    (deviceExtension->FullIdentifyData.NumberOfHeads *
                       deviceExtension->FullIdentifyData.SectorsPerTrack));
 
            KdPrint2((PRINT_PREFIX "cylinders %#I64x\n", cylinders));
 
            NumOfSectors = cylinders *
                           deviceExtension->FullIdentifyData.NumberOfHeads *
                           deviceExtension->FullIdentifyData.SectorsPerTrack;
 
            KdPrint2((PRINT_PREFIX "NumOfSectors %#I64x\n", NumOfSectors));
        } else {
 
        }
        // Check for LBA mode
        KdPrint2((PRINT_PREFIX "SupportLba flag %#x\n", deviceExtension->FullIdentifyData.SupportLba));
        KdPrint2((PRINT_PREFIX "SupportDMA flag %#x\n", deviceExtension->FullIdentifyData.SupportDma));
        KdPrint2((PRINT_PREFIX "SoftReset %#x\n", deviceExtension->FullIdentifyData.SoftReset));
        KdPrint2((PRINT_PREFIX "SupportIordy %#x, DisableIordy %#x\n",
            deviceExtension->FullIdentifyData.SupportIordy,
            deviceExtension->FullIdentifyData.DisableIordy
            ));
        KdPrint2((PRINT_PREFIX "MajorRevision %#x\n", deviceExtension->FullIdentifyData.MajorRevision));
        KdPrint2((PRINT_PREFIX "UserAddressableSectors %#x\n", deviceExtension->FullIdentifyData.UserAddressableSectors));
        if ( deviceExtension->FullIdentifyData.SupportLba
                            ||
            (deviceExtension->FullIdentifyData.MajorRevision &&
/*             deviceExtension->FullIdentifyData.TranslationFieldsValid &&*/
             deviceExtension->FullIdentifyData.UserAddressableSectors)) {
            KdPrint2((PRINT_PREFIX "LBA mode\n"));
            LunExt->DeviceFlags |= DFLAGS_LBA_ENABLED;
        } else {
            KdPrint2((PRINT_PREFIX "Keep orig geometry\n"));
            LunExt->DeviceFlags |= DFLAGS_ORIG_GEOMETRY;
            goto skip_lba_staff;
        }
        // Check for LBA48 support
        if(LunExt->DeviceFlags & DFLAGS_LBA_ENABLED) {
            if(deviceExtension->FullIdentifyData.FeaturesSupport.Address48 &&
               deviceExtension->FullIdentifyData.FeaturesEnabled.Address48 &&
               deviceExtension->FullIdentifyData.NumberOfHeads &&
               deviceExtension->FullIdentifyData.SectorsPerTrack &&
               (deviceExtension->FullIdentifyData.UserAddressableSectors48 > NumOfSectors)
               ) {
                KdPrint2((PRINT_PREFIX "LBA48\n"));
                cylinders =
                    (deviceExtension->FullIdentifyData.UserAddressableSectors48 /
                        (deviceExtension->FullIdentifyData.NumberOfHeads *
                           deviceExtension->FullIdentifyData.SectorsPerTrack));
 
                KdPrint2((PRINT_PREFIX "cylinders %#I64x\n", cylinders));
 
                NativeNumOfSectors = cylinders *
                               deviceExtension->FullIdentifyData.NumberOfHeads *
                               deviceExtension->FullIdentifyData.SectorsPerTrack;
 
                KdPrint2((PRINT_PREFIX "NativeNumOfSectors %#I64x\n", NativeNumOfSectors));
 
                if(NativeNumOfSectors > NumOfSectors) {
                    KdPrint2((PRINT_PREFIX "Update NumOfSectors to %#I64x\n", NativeNumOfSectors));
                    NumOfSectors = NativeNumOfSectors;
                }
            }
 
            // Check drive capacity report for LBA48-capable drives.
            if(deviceExtension->FullIdentifyData.FeaturesSupport.Address48) {
                ULONG hNativeNumOfSectors;
                KdPrint2((PRINT_PREFIX "Use IDE_COMMAND_READ_NATIVE_SIZE48\n"));
 
                statusByte = AtaCommand48(deviceExtension, DeviceNumber, lChannel,
                             IDE_COMMAND_READ_NATIVE_SIZE48, 0, 0, 0, ATA_WAIT_READY);
 
                if(!(statusByte & IDE_STATUS_ERROR)) {
                    if(use_ahci) {
                        NativeNumOfSectors = chan->AhciInternalAtaReq->ahci.in_lba;
                    } else {
                        NativeNumOfSectors = (ULONG)AtapiReadPort1(chan, IDX_IO1_i_BlockNumber) |
                                            ((ULONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderLow)  << 8) |
                                            ((ULONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh) << 16) ;
 
                        AtapiWritePort1(chan, IDX_IO2_o_Control,
                                               IDE_DC_USE_HOB );
 
                        KdPrint2((PRINT_PREFIX "Read high order bytes\n"));
                        NativeNumOfSectors |=
                                            (ULONG)((ULONG)AtapiReadPort1(chan, IDX_IO1_i_BlockNumber)  << 24 );
                        hNativeNumOfSectors=
                                             (ULONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderLow) |
                                            ((ULONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh) << 8) ;
                        ((PULONG)&NativeNumOfSectors)[1] = hNativeNumOfSectors;
                    }
                    KdPrint2((PRINT_PREFIX "NativeNumOfSectors %#I64x\n", NativeNumOfSectors));
 
                    // Some drives report LBA48 capability while has capacity below 128Gb
                    // Probably they support large block-counters.
                    // But the problem is that some of them reports higher part of Max LBA equal to lower part.
                    // Here we check this
                    if((NativeNumOfSectors & 0xffffff) == ((NativeNumOfSectors >> 24) & 0xffffff)) {
                        KdPrint2((PRINT_PREFIX "High-order bytes == Low-order bytes !!!\n"));
 
                        statusByte = AtaCommand48(deviceExtension, DeviceNumber, lChannel,
                                     IDE_COMMAND_READ_NATIVE_SIZE48, 0, 0, 0, ATA_WAIT_READY);
 
                        if(!(statusByte & IDE_STATUS_ERROR)) {
                            if(use_ahci) {
                                NativeNumOfSectors = chan->AhciInternalAtaReq->ahci.in_lba;
                            } else {
                                NativeNumOfSectors = (ULONGLONG)AtapiReadPort1(chan, IDX_IO1_i_BlockNumber) |
                                                ((ULONGLONG)AtapiReadPort1(chan, IDX_IO1_i_BlockNumber)  << 24) |
                                                ((ULONGLONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderLow)  << 8 ) |
                                                ((ULONGLONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderLow)  << 32) |
                                                ((ULONGLONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh) << 16) |
                                                ((ULONGLONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh) << 40)
                                                ;
                            }
                        }
 
                        if((NativeNumOfSectors & 0xffffff) == ((NativeNumOfSectors >> 24) & 0xffffff)) {
                            KdPrint2((PRINT_PREFIX "High-order bytes == Low-order bytes !!! (2)\n"));
                            NativeNumOfSectors = 0;
                        }
                    }
 
                    if(NumOfSectors <= ATA_MAX_LBA28 &&
                       NativeNumOfSectors > NumOfSectors) {
 
                        KdPrint2((PRINT_PREFIX "Use IDE_COMMAND_SET_NATIVE_SIZE48\n"));
                        KdPrint2((PRINT_PREFIX "Update NumOfSectors to %#I64x\n", NativeNumOfSectors));
 
                        statusByte = AtaCommand48(deviceExtension, DeviceNumber, lChannel,
                                     IDE_COMMAND_SET_NATIVE_SIZE, NativeNumOfSectors, 0, 0, ATA_WAIT_READY);
                        if(!(statusByte & IDE_STATUS_ERROR)) {
                            NumOfSectors = NativeNumOfSectors;
                        }
                    }
                } // !error
            }
 
            if(NumOfSectors < 0x2100000 /*&& NumOfSectors > 31*1000*1000*/) {
                // check for native LBA size
                // some drives report ~32Gb in Identify Block
                KdPrint2((PRINT_PREFIX "Use IDE_COMMAND_READ_NATIVE_SIZE\n"));
 
                statusByte = AtaCommand(deviceExtension, DeviceNumber, lChannel, IDE_COMMAND_READ_NATIVE_SIZE,
                             0, IDE_USE_LBA, 0, 0, 0, ATA_WAIT_READY);
 
                if(!(statusByte & IDE_STATUS_ERROR)) {
                    if(use_ahci) {
                        NativeNumOfSectors = chan->AhciInternalAtaReq->ahci.in_lba;
                    } else {
                        NativeNumOfSectors = (ULONG)AtapiReadPort1(chan, IDX_IO1_i_BlockNumber) |
                                            ((ULONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderLow) << 8) |
                                            ((ULONG)AtapiReadPort1(chan, IDX_IO1_i_CylinderHigh) << 16) |
                                           (((ULONG)AtapiReadPort1(chan, IDX_IO1_i_DriveSelect) & 0xf) << 24);
                    }
                    KdPrint2((PRINT_PREFIX "NativeNumOfSectors %#I64x\n", NativeNumOfSectors));
 
                    if(NativeNumOfSectors > NumOfSectors) {
 
                        KdPrint2((PRINT_PREFIX "Use IDE_COMMAND_SET_NATIVE_SIZE\n"));
                        KdPrint2((PRINT_PREFIX "Update NumOfSectors to %#I64x\n", NativeNumOfSectors));
 
                        statusByte = AtaCommand48(deviceExtension, DeviceNumber, lChannel,
                                     IDE_COMMAND_SET_NATIVE_SIZE, NativeNumOfSectors, 0, 0, ATA_WAIT_READY);
                        if(!(statusByte & IDE_STATUS_ERROR)) {
                            NumOfSectors = NativeNumOfSectors;
                        }
                    }
                }
            }
 
            if(NumOfSectors > ATA_MAX_IOLBA28) {
              KdPrint2((PRINT_PREFIX "2TB threshold, force LBA64 WRITE requirement\n"));
              LunExt->DeviceFlags |= DFLAGS_LBA32plus;
            }
        } // if(LunExt->DeviceFlags & DFLAGS_LBA_ENABLED)
 
        // fill IdentifyData with bogus geometry
        KdPrint2((PRINT_PREFIX "requested LunExt->GeomType=%x\n", LunExt->opt_GeomType));
        if(deviceExtension->FullIdentifyData.CurrentSectorsPerTrack &&
           deviceExtension->FullIdentifyData.NumberOfCurrentHeads) {
          tmp_cylinders = NumOfSectors / (deviceExtension->FullIdentifyData.CurrentSectorsPerTrack *
                                          deviceExtension->FullIdentifyData.NumberOfCurrentHeads);
        } else
        if(deviceExtension->FullIdentifyData.SectorsPerTrack &&
           deviceExtension->FullIdentifyData.NumberOfHeads) {
            KdPrint2((PRINT_PREFIX "Current C/H = %#I64x/%#I64x\n",
                deviceExtension->FullIdentifyData.CurrentSectorsPerTrack,
                deviceExtension->FullIdentifyData.NumberOfCurrentHeads));
            tmp_cylinders = NumOfSectors / (deviceExtension->FullIdentifyData.SectorsPerTrack *
                                            deviceExtension->FullIdentifyData.NumberOfHeads);
        } else {
            tmp_cylinders = 0;
        }
        KdPrint2((PRINT_PREFIX "tmp_cylinders = %#I64x\n", tmp_cylinders));
        if((tmp_cylinders < 0xffff) || (LunExt->opt_GeomType == GEOM_ORIG)) {
            // ok, we can keep original values
            if(LunExt->opt_GeomType == GEOM_AUTO) {
                LunExt->opt_GeomType = GEOM_ORIG;
            }
        } else {
            tmp_cylinders = NumOfSectors / (255*63);
            if(tmp_cylinders < 0xffff) {
                // we can use generic values for H/S for generic geometry approach
                if(LunExt->opt_GeomType == GEOM_AUTO) {
                    LunExt->opt_GeomType = GEOM_STD;
                }
            } else {
                // we should use UNIATA geometry approach
                if(LunExt->opt_GeomType == GEOM_AUTO) {
                    LunExt->opt_GeomType = GEOM_UNIATA;
                }
            }
        }
 
        if(!deviceExtension->FullIdentifyData.SectorsPerTrack ||
           !deviceExtension->FullIdentifyData.NumberOfHeads) {
            KdPrint2((PRINT_PREFIX "Zero S/H -> Force Use GEOM_STD\n"));
        }
 
        if(LunExt->opt_GeomType == GEOM_STD) {
            deviceExtension->FullIdentifyData.CurrentSectorsPerTrack =
            deviceExtension->FullIdentifyData.SectorsPerTrack = 63;
 
            deviceExtension->FullIdentifyData.NumberOfCurrentHeads =
            deviceExtension->FullIdentifyData.NumberOfHeads   = 255;
 
            cylinders = NumOfSectors / (255*63);
            KdPrint2((PRINT_PREFIX "Use GEOM_STD, CHS=%I64x/%x/%x\n", cylinders, 255, 63));
        } else
        if(LunExt->opt_GeomType == GEOM_UNIATA) {
            while ((cylinders > 0xffff) && (deviceExtension->FullIdentifyData.SectorsPerTrack < 0x80)) {
                cylinders /= 2;
                KdPrint2((PRINT_PREFIX "cylinders /= 2\n"));
                deviceExtension->FullIdentifyData.SectorsPerTrack *= 2;
                deviceExtension->FullIdentifyData.CurrentSectorsPerTrack *= 2;
            }
            while ((cylinders > 0xffff) && (deviceExtension->FullIdentifyData.NumberOfHeads < 0x80)) {
                cylinders /= 2;
                KdPrint2((PRINT_PREFIX "cylinders /= 2 (2)\n"));
                deviceExtension->FullIdentifyData.NumberOfHeads *= 2;
                deviceExtension->FullIdentifyData.NumberOfCurrentHeads *= 2;
            }
            while ((cylinders > 0xffff) && (deviceExtension->FullIdentifyData.SectorsPerTrack < 0x8000)) {
                cylinders /= 2;
                KdPrint2((PRINT_PREFIX "cylinders /= 2 (3)\n"));
                deviceExtension->FullIdentifyData.SectorsPerTrack *= 2;
                deviceExtension->FullIdentifyData.CurrentSectorsPerTrack *= 2;
            }
            while ((cylinders > 0xffff) && (deviceExtension->FullIdentifyData.NumberOfHeads < 0x8000)) {
                cylinders /= 2;
                KdPrint2((PRINT_PREFIX "cylinders /= 2 (4)\n"));
                deviceExtension->FullIdentifyData.NumberOfHeads *= 2;
                deviceExtension->FullIdentifyData.NumberOfCurrentHeads *= 2;
            }
            KdPrint2((PRINT_PREFIX "Use GEOM_UNIATA, CHS=%I64x/%x/%x\n", cylinders,
                deviceExtension->FullIdentifyData.NumberOfCurrentHeads,
                deviceExtension->FullIdentifyData.CurrentSectorsPerTrack));
        }
        if(!cylinders) {
            KdPrint2((PRINT_PREFIX "cylinders = tmp_cylinders (%x = %x)\n", cylinders, tmp_cylinders));
            cylinders = tmp_cylinders;
        }
        deviceExtension->FullIdentifyData.NumberOfCurrentCylinders =
        deviceExtension->FullIdentifyData.NumberOfCylinders = (USHORT)cylinders;
 
skip_lba_staff:
 
        KdPrint2((PRINT_PREFIX "Geometry: C %#x (%#x)\n",
                  deviceExtension->FullIdentifyData.NumberOfCylinders,
                  deviceExtension->FullIdentifyData.NumberOfCurrentCylinders
                  ));
        KdPrint2((PRINT_PREFIX "Geometry: H %#x (%#x)\n",
                  deviceExtension->FullIdentifyData.NumberOfHeads,
                  deviceExtension->FullIdentifyData.NumberOfCurrentHeads
                  ));
        KdPrint2((PRINT_PREFIX "Geometry: S %#x (%#x)\n",
                  deviceExtension->FullIdentifyData.SectorsPerTrack,
                  deviceExtension->FullIdentifyData.CurrentSectorsPerTrack
                  ));
 
        if(NumOfSectors) {
            LunExt->NumOfSectors = NumOfSectors;
        }
        if(deviceExtension->FullIdentifyData.MajorRevision &&
           deviceExtension->FullIdentifyData.DoubleWordIo) {
            LunExt->DeviceFlags |= DFLAGS_DWORDIO_ENABLED;
            KdPrint2((PRINT_PREFIX "IssueIdentify: DWORDIO supported\n"));
        }
    } else {
        // ATAPI
        if(deviceExtension->FullIdentifyData.MajorRevision &&
           deviceExtension->FullIdentifyData.DoubleWordIo) {
            LunExt->DeviceFlags |= DFLAGS_DWORDIO_ENABLED;
            KdPrint2((PRINT_PREFIX "IssueIdentify: DFLAGS_DWORDIO_ENABLED.\n"));
        }
        if(deviceExtension->FullIdentifyData.AtapiDMA.DMADirRequired) {
            KdPrint2((PRINT_PREFIX "DMADirRequired.\n"));
        }
        if(deviceExtension->FullIdentifyData.AtapiByteCount0) {
            KdPrint2((PRINT_PREFIX "AtapiByteCount0=%x\n", deviceExtension->FullIdentifyData.AtapiByteCount0));
        }
    }
 
    ScsiPortMoveMemory(&LunExt->IdentifyData,
                       &deviceExtension->FullIdentifyData,sizeof(IDENTIFY_DATA2));
 
    InitBadBlocks(LunExt);
 
    if ((LunExt->IdentifyData.DrqType & ATAPI_DRQT_INTR) &&
        (Command != IDE_COMMAND_IDENTIFY)) {
 
        // This device interrupts with the assertion of DRQ after receiving
        // Atapi Packet Command
        LunExt->DeviceFlags |= DFLAGS_INT_DRQ;
        KdPrint2((PRINT_PREFIX "IssueIdentify: Device interrupts on assertion of DRQ.\n"));
 
    } else {
        KdPrint2((PRINT_PREFIX "IssueIdentify: Device does not interrupt on assertion of DRQ.\n"));
    }
 
    if(Command != IDE_COMMAND_IDENTIFY) {
        // ATAPI branch
        if(LunExt->IdentifyData.DeviceType == ATAPI_TYPE_TAPE) {
            // This is a tape.
            LunExt->DeviceFlags |= DFLAGS_TAPE_DEVICE;
            KdPrint2((PRINT_PREFIX "IssueIdentify: Device is a tape drive.\n"));
        } else
        if(LunExt->IdentifyData.DeviceType == ATAPI_TYPE_CDROM ||
            LunExt->IdentifyData.DeviceType == ATAPI_TYPE_OPTICAL) {
            KdPrint2((PRINT_PREFIX "IssueIdentify: Device is CD/Optical drive.\n"));
            // set CD default costs
            LunExt->RwSwitchCost  = REORDER_COST_SWITCH_RW_CD;
            LunExt->RwSwitchMCost = REORDER_MCOST_SWITCH_RW_CD;
            LunExt->SeekBackMCost = REORDER_MCOST_SEEK_BACK_CD;
            statusByte = WaitForDrq(chan);
        } else {
            KdPrint2((PRINT_PREFIX "IssueIdentify: ATAPI drive type %#x.\n",
                LunExt->IdentifyData.DeviceType));
        }
        KdPrint2((PRINT_PREFIX "IssueIdentify: AtapiCmdSize %#x\n", deviceExtension->FullIdentifyData.AtapiCmdSize));
    } else {
        KdPrint2((PRINT_PREFIX "IssueIdentify: hard drive.\n"));
    }
 
    GetBaseStatus(chan, statusByte);
    KdPrint2((PRINT_PREFIX "IssueIdentify: final Status on exit (%#x)\n", statusByte));
    return TRUE;
 
} // end IssueIdentify()
 
 
/*++
 
Routine Description:
    Set drive parameters using the IDENTIFY data.
 
Arguments:
    HwDeviceExtension - HBA miniport driver's adapter data storage
    DeviceNumber - Indicates which device.
 
Return Value:
    TRUE if all goes well.
 
--*/
BOOLEAN
NTAPI
SetDriveParameters(
    IN PVOID HwDeviceExtension,
    IN ULONG DeviceNumber,
    IN ULONG lChannel
    )
{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    PIDENTIFY_DATA2      identifyData;
    PHW_LU_EXTENSION     LunExt;
//    ULONG i;
    UCHAR statusByte;
    UCHAR errorByte;
 
    LunExt = deviceExtension->chan[lChannel].lun[DeviceNumber];
    identifyData = &(LunExt->IdentifyData);
 
    if(LunExt->DeviceFlags &
          (DFLAGS_LBA_ENABLED | DFLAGS_ORIG_GEOMETRY))
       return TRUE;
 
    KdPrint2((PRINT_PREFIX "SetDriveParameters: Number of heads %#x\n", identifyData->NumberOfHeads));
    KdPrint2((PRINT_PREFIX "SetDriveParameters: Sectors per track %#x\n", identifyData->SectorsPerTrack));
 
    // Send SET PARAMETER command.
    statusByte = AtaCommand(deviceExtension, DeviceNumber, lChannel,
                            IDE_COMMAND_SET_DRIVE_PARAMETERS, 0,
                            (identifyData->NumberOfHeads - 1), 0,
                            (UCHAR)identifyData->SectorsPerTrack, 0, ATA_WAIT_IDLE);
 
    statusByte = UniataIsIdle(deviceExtension, statusByte);
    if(statusByte & IDE_STATUS_ERROR) {
        errorByte = AtapiReadPort1(&deviceExtension->chan[lChannel], IDX_IO1_i_Error);
        KdPrint2((PRINT_PREFIX "SetDriveParameters: Error bit set. Status %#x, error %#x\n",
                    errorByte, statusByte));
        return FALSE;
    }
 
    if(statusByte == IDE_STATUS_IDLE) {
        return TRUE;
    }
 
    return FALSE;
 
} // end SetDriveParameters()
 
VOID
NTAPI
UniataForgetDevice(
    PHW_LU_EXTENSION   LunExt
    )
{
    // keep only DFLAGS_HIDDEN flag
    LunExt->DeviceFlags &= DFLAGS_HIDDEN;
    LunExt->AtapiReadyWaitDelay = 0;
} // end UniataForgetDevice()
 
 
/*++
 
Routine Description:
    Reset IDE controller and/or Atapi device.
    ->HwResetBus
 
Arguments:
    HwDeviceExtension - HBA miniport driver's adapter data storage
 
Return Value:
    Nothing.
 
 
--*/
BOOLEAN
NTAPI
AtapiResetController(
    IN PVOID HwDeviceExtension,
    IN ULONG PathId
    )
{
    KdPrint2((PRINT_PREFIX "AtapiResetController(%x)\n", PathId));
    return AtapiResetController__(HwDeviceExtension, PathId, RESET_COMPLETE_ALL);
} // end AtapiResetController()
 
BOOLEAN
NTAPI
AtapiResetController__(
    IN PVOID HwDeviceExtension,
    IN ULONG PathId,
    IN BOOLEAN CompleteType
    )
{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    ULONG                numberChannels  = deviceExtension->NumberChannels;
    PHW_CHANNEL          chan = NULL;
    ULONG i,j;
    ULONG MaxLuns;
    UCHAR statusByte;
    PSCSI_REQUEST_BLOCK CurSrb;
    ULONG ChannelCtrlFlags;
    UCHAR dma_status = 0;
 
    ULONG slotNumber = deviceExtension->slotNumber;
    ULONG SystemIoBusNumber = deviceExtension->SystemIoBusNumber;
    ULONG VendorID =  deviceExtension->DevID        & 0xffff;
#ifdef _DEBUG
    ULONG DeviceID = (deviceExtension->DevID >> 16) & 0xffff;
#endif
    //ULONG RevID    =  deviceExtension->RevID;
    ULONG ChipFlags = deviceExtension->HwFlags & CHIPFLAG_MASK;
    //UCHAR tmp8;
    USHORT tmp16;
 
    KdPrint2((PRINT_PREFIX "AtapiResetController: Reset IDE %#x/%#x @ %#x\n", VendorID, DeviceID, slotNumber));
    KdPrint2((PRINT_PREFIX "simplexOnly %d, VM %x\n", deviceExtension->simplexOnly, g_opt_VirtualMachine));
 
    if(!deviceExtension->simplexOnly && (PathId != CHAN_NOT_SPECIFIED)) {
        // we shall reset both channels on SimplexOnly devices,
        // It's not worth doing so on normal controllers
        j = PathId;
        numberChannels = min(j+1, deviceExtension->NumberChannels);
    } else {
        j=0;
        numberChannels = deviceExtension->NumberChannels;
    }
 
    for (; j < numberChannels; j++) {
 
        KdPrint2((PRINT_PREFIX "AtapiResetController: Reset lchannel %d[%d]\n", j, deviceExtension->Channel));
        chan = &(deviceExtension->chan[j]);
        MaxLuns = chan->NumberLuns;
        // Save control flags
        ChannelCtrlFlags = chan->ChannelCtrlFlags;
        KdPrint2((PRINT_PREFIX "  CompleteType %#x, Luns %d, chan %#x, sptr %#x, flags %#x\n", CompleteType, MaxLuns, chan, &chan, ChannelCtrlFlags));
        //MaxLuns = (chan->ChannelCtrlFlags & CTRFLAGS_NO_SLAVE) ? 1 : 2;
        if(CompleteType != RESET_COMPLETE_NONE) {
#ifndef UNIATA_CORE
            while((CurSrb = UniataGetCurRequest(chan))) {
 
                PHW_LU_EXTENSION     LunExt;
                PATA_REQ AtaReq = (PATA_REQ)(CurSrb->SrbExtension);
 
                i = GET_CDEV(CurSrb);
                KdPrint2((PRINT_PREFIX "  Lun %x\n", i));
                LunExt = chan->lun[i];
 
                KdPrint2((PRINT_PREFIX "AtapiResetController: pending SRB %#x, chan %#x\n", CurSrb, chan));
                if(CurSrb->Cdb[0] == SCSIOP_MECHANISM_STATUS) {
                    KdPrint2((PRINT_PREFIX "  was MechStatus\n"));
 
                    if(!(LunExt->DeviceFlags & DFLAGS_CHANGER_INITED)) {
                        LunExt->DeviceFlags |= DFLAGS_CHANGER_INITED;
                        KdPrint2((PRINT_PREFIX "  set DFLAGS_CHANGER_INITED\n"));
                    }
                }
                // Check and see if we are processing an internal srb
                if (AtaReq->OriginalSrb) {
                    KdPrint2((PRINT_PREFIX "  restore original SRB %#x\n", AtaReq->OriginalSrb));
                    AtaReq->Srb = AtaReq->OriginalSrb;
                    CurSrb->SrbExtension = NULL;
                    AtaReq->OriginalSrb = NULL;
                    // NOTE: internal SRB doesn't get to SRB queue !!!
                    CurSrb = AtaReq->Srb;
                }
 
                // Remove current request from queue
                UniataRemoveRequest(chan, CurSrb);
 
                // Check if request is in progress.
                ASSERT(AtaReq->Srb == CurSrb);
                if (CurSrb) {
                    // Complete outstanding request with SRB_STATUS_BUS_RESET.
                    UCHAR CurPathId = CurSrb->PathId;
                    UCHAR TargetId = CurSrb->TargetId;
                    UCHAR Lun = CurSrb->Lun;
 
                    CurSrb->SrbStatus = ((CompleteType == RESET_COMPLETE_ALL) ? SRB_STATUS_BUS_RESET : SRB_STATUS_ABORTED) | SRB_STATUS_AUTOSENSE_VALID;
                    CurSrb->ScsiStatus = SCSISTAT_CHECK_CONDITION;
 
                    if (CurSrb->SenseInfoBuffer) {
 
                        PSENSE_DATA  senseBuffer = (PSENSE_DATA)CurSrb->SenseInfoBuffer;
                        KdPrint2((PRINT_PREFIX "  senseBuffer %#x, chan %#x, ReqFlags %#x\n", senseBuffer, chan, AtaReq->Flags));
 
                        senseBuffer->ErrorCode = 0x70;
                        senseBuffer->Valid     = 1;
                        senseBuffer->AdditionalSenseLength = 0xb;
                        if(CompleteType == RESET_COMPLETE_ALL) {
                            KdPrint2((PRINT_PREFIX "AtapiResetController: report SCSI_SENSE_UNIT_ATTENTION + SCSI_ADSENSE_BUS_RESET\n"));
                            senseBuffer->SenseKey = SCSI_SENSE_UNIT_ATTENTION;
                            senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_BUS_RESET;
                            senseBuffer->AdditionalSenseCodeQualifier = SCSI_SENSEQ_SCSI_BUS;
                        } else {
                            KdPrint2((PRINT_PREFIX "AtapiResetController: report SCSI_SENSE_ABORTED_COMMAND\n"));
                            senseBuffer->SenseKey = SCSI_SENSE_ABORTED_COMMAND;
                            senseBuffer->AdditionalSenseCode = 0;
                            senseBuffer->AdditionalSenseCodeQualifier = 0;
                        }
                    }
 
                    if(!ATAPI_DEVICE(chan, i) && AtaReq->bcount && AtaReq->retry < MAX_RETRIES) {
                        KdPrint2((PRINT_PREFIX "Save IDE retry status %d\n", AtaReq->retry));
                        LunExt->errLastLba = AtaReq->lba;
                        LunExt->errBCount = AtaReq->bcount;
                        LunExt->errRetry = AtaReq->retry+1;
                        //KdPrint2((PRINT_PREFIX "AtaReq->Flags & REQ_FLAG_RW_MASK = %x (%x)\n", (AtaReq->Flags & REQ_FLAG_RW_MASK), REQ_FLAG_READ));
                        //KdPrint2((PRINT_PREFIX "ChannelCtrlFlags & CTRFLAGS_DMA_OPERATION = %x (%x)\n", ChannelCtrlFlags & CTRFLAGS_DMA_ACTIVE, CTRFLAGS_DMA_OPERATION));
                        //KdPrint2((PRINT_PREFIX "g_opt_VirtualMachine = %x (%x)\n", g_opt_VirtualMachine, VM_BOCHS));
                        if(((AtaReq->Flags & REQ_FLAG_RW_MASK) == REQ_FLAG_READ) &&
                           (ChannelCtrlFlags & CTRFLAGS_DMA_OPERATION) &&
                           (g_opt_VirtualMachine == VM_BOCHS)) {
                            KdPrint2((PRINT_PREFIX "set CTRFLAGS_DMA_BEFORE_R on BOCHS\n"));
                            g_opt_BochsDmaReadWorkaround = TRUE;
                            g_opt_AtapiNoDma = TRUE;
                        } else {
                            KdPrint2((PRINT_PREFIX "do nothing\n"));
                        }
                    } else
                    if(ATAPI_DEVICE(chan, i) && AtaReq->bcount && !AtaReq->retry) {
                        KdPrint2((PRINT_PREFIX "Save ATAPI retry status %d\n", AtaReq->retry));
                        LunExt->errLastLba = AtaReq->lba;
                        LunExt->errBCount = AtaReq->bcount;
                        LunExt->errRetry = AtaReq->retry+1;
                        if(((AtaReq->Flags & REQ_FLAG_RW_MASK) == REQ_FLAG_READ) &&
                           (ChannelCtrlFlags & CTRFLAGS_DMA_OPERATION) &&
                           (g_opt_VirtualMachine == VM_BOCHS)) {
                            KdPrint2((PRINT_PREFIX "set CTRFLAGS_DMA_BEFORE_R on BOCHS ATAPI\n"));
                            //g_opt_BochsDmaReadWorkaround = TRUE;
                            g_opt_AtapiNoDma = TRUE;
                        } else {
                            KdPrint2((PRINT_PREFIX "do nothing\n"));
                        }
                    } else {
                        LunExt->errRetry = 0;
                    }
 
                    // Clear request tracking fields.
                    AtaReq->WordsLeft = 0;
                    AtaReq->DataBuffer = NULL;
                    AtaReq->TransferLength = 0;
                    KdPrint2((PRINT_PREFIX "chan %#x\n", chan));
 
                    ScsiPortNotification(RequestComplete,
                                         deviceExtension,
                                         CurSrb);
 
                    // Indicate ready for next request.
                    ScsiPortNotification(NextLuRequest,
                                         deviceExtension,
                                         CurPathId,
                                         TargetId,
                                         Lun);
                }
                if(CompleteType != RESET_COMPLETE_ALL)
                    break;
            } // end while()
#endif //UNIATA_CORE
        } // end if (!CompleteType != RESET_COMPLETE_NONE)
 
        // Clear expecting interrupt flag.
        UniataExpectChannelInterrupt(chan, FALSE);
        chan->RDP = FALSE;
        chan->ChannelCtrlFlags = ChannelCtrlFlags & CTRFLAGS_PERMANENT;
        InterlockedExchange(&(chan->CheckIntr),
                                      CHECK_INTR_IDLE);
 
        for (i = 0; i < MaxLuns; i++) {
            chan->lun[i]->PowerState = 0;
        }
        // Reset controller
        if(ChipFlags & UNIATA_AHCI) {
            KdPrint2((PRINT_PREFIX "  AHCI path\n"));
            if(UniataAhciChanImplemented(deviceExtension, j)) {
#ifdef _DEBUG
                UniataDumpAhciPortRegs(chan);
#endif
                AtapiDisableInterrupts(deviceExtension, j);
                UniataAhciReset(HwDeviceExtension, j);
            } else {
                KdPrint2((PRINT_PREFIX "  skip not implemented\n"));
                continue;
            }
        } else {
            KdPrint2((PRINT_PREFIX "  ATA path, chan %#x\n", chan));
            KdPrint2((PRINT_PREFIX "  disable intr (0)\n"));
            AtapiDisableInterrupts(deviceExtension, j);
            KdPrint2((PRINT_PREFIX "  done\n"));
            switch(VendorID) {
            case ATA_INTEL_ID: {
                ULONG mask;
                ULONG pshift;
                ULONG timeout;
                if(!(ChipFlags & UNIATA_SATA)) {
                    goto default_reset;
                }
                if(!UniataIsSATARangeAvailable(deviceExtension, j)) {
                    goto default_reset;
                }
 
#if 0
                /* ICH6 & ICH7 in compat mode has 4 SATA ports as master/slave on 2 ch's */
                if(ChipFlags & UNIATA_AHCI) {
                    mask = 0x0005 << j;
                } else {
                    /* ICH5 in compat mode has SATA ports as master/slave on 1 channel */
                    GetPciConfig1(0x90, tmp8);
                    if(tmp8 & 0x04) {
                        mask = 0x0003;
                    } else {
                        mask = 0x0001 << j;
                    }
                }
#else
                mask = 1 << chan->lun[0]->SATA_lun_map;
                if (MaxLuns > 1) {
                    mask |= (1 << chan->lun[1]->SATA_lun_map);
                }
#endif
                ChangePciConfig2(0x92, a & ~mask);
                AtapiStallExecution(10);
                ChangePciConfig2(0x92, a | mask);
                timeout = 100;
 
                /* Wait up to 1 sec for "connect well". */
                if (ChipFlags & (I6CH | I6CH2)) {
                    pshift = 8;
                } else {
                    pshift = 4;
                }
                while (timeout--) {
                    GetPciConfig2(0x92, tmp16);
                    if (((tmp16 >> pshift) & mask) == mask) {
                        GetBaseStatus(chan, statusByte);
                        if(statusByte != IDE_STATUS_WRONG) {
                            break;
                        }
                    }
                    AtapiStallExecution(10000);
                }
                break; }
            case ATA_SIS_ID: {
                KdPrint2((PRINT_PREFIX "  SIS\n"));
                if(!(ChipFlags & UNIATA_SATA))
                    goto default_reset;
                break; }
#if 0
            case ATA_NVIDIA_ID: {
                KdPrint2((PRINT_PREFIX "  nVidia\n"));
                if(!(ChipFlags & UNIATA_SATA))
                    goto default_reset;
                break; }
#else
            case ATA_NVIDIA_ID: {
                ULONG offs;
                ULONG Channel = deviceExtension->Channel + j;
                KdPrint2((PRINT_PREFIX "  nVidia\n"));
                if(!(ChipFlags & UNIATA_SATA)) {
                    goto default_reset;
                }
                offs = (ChipFlags & NV4OFF) ? 0x0440 : 0x0010;
 
                KdPrint2((PRINT_PREFIX "  disable Phy intr, offs %#x, c %u\n", offs, Channel));
                /* disable device and PHY state change interrupts */
                if(ChipFlags & NVQ) {
                    KdPrint2((PRINT_PREFIX "  NVQ, 32bits reg\n"));
                    AtapiWritePortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+4,
                        AtapiReadPortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+4) & ((~(ULONG)0x0000000d) << (!Channel*16)) );
                } else {
                    AtapiWritePortEx1(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+1,
                        AtapiReadPortEx1(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+1) & ((~(UCHAR)0x0d) << (!Channel*4)) );
                }
                tmp16 = UniataSataPhyEnable(HwDeviceExtension, j, 0/* dev0*/, UNIATA_SATA_RESET_ENABLE);
 
                KdPrint2((PRINT_PREFIX "  enable Phy intr, offs %#x\n", offs));
                /* enable device and PHY state change interrupts */
                if(ChipFlags & NVQ) {
                    AtapiWritePortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+4,
                        AtapiReadPortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+4) | (((ULONG)0x0000000d) << (!Channel*16)) );
                } else {
                    AtapiWritePortEx1(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+1,
                        AtapiReadPortEx1(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0),offs+1) | (((UCHAR)0x0d) << (!Channel*4)) );
                }
 
                KdPrint2((PRINT_PREFIX "  dev status %#x\n", tmp16));
                if(tmp16 != IDE_STATUS_WRONG) {
                    goto default_reset;
                }
                break; }
#endif //0
            case ATA_SILICON_IMAGE_ID: {
                ULONG offset;
                ULONG Channel = deviceExtension->Channel + j;
                if(!(ChipFlags & UNIATA_SATA))
                    goto default_reset;
                offset = ((Channel & 1) << 7) + ((Channel & 2) << 8);
                /* disable PHY state change interrupt */
                AtapiWritePortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0), 0x148 + offset, 0);
 
                UniataSataClearErr(HwDeviceExtension, j, UNIATA_SATA_IGNORE_CONNECT, 0);
 
                /* reset controller part for this channel */
                AtapiWritePortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0), 0x48,
                     AtapiReadPortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0), 0x48) | (0xc0 >> Channel));
                AtapiStallExecution(1000);
                AtapiWritePortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0), 0x48,
                     AtapiReadPortEx4(NULL, (ULONGIO_PTR)(&deviceExtension->BaseIoAddressSATA_0), 0x48) & ~(0xc0 >> Channel));
 
 
                break; }
            case ATA_PROMISE_ID: {
                break; }
            default:
                if(ChipFlags & UNIATA_SATA) {
                    KdPrint2((PRINT_PREFIX "  SATA generic reset\n"));
                    UniataSataClearErr(HwDeviceExtension, j, UNIATA_SATA_IGNORE_CONNECT, 0);
                }
default_reset:
/*
                AtapiWritePort1(chan, IDX_IO2_o_Control, IDE_DC_DISABLE_INTERRUPTS |
                                                                        IDE_DC_RESET_CONTROLLER );
                chan->last_devsel = -1;
                KdPrint2((PRINT_PREFIX "  wait a little\n"));
                AtapiStallExecution(10000);
                // Disable interrupts
                KdPrint2((PRINT_PREFIX "  disable intr\n"));
                AtapiDisableInterrupts(deviceExtension, j);
                AtapiStallExecution(100);
                KdPrint2((PRINT_PREFIX "  re-enable intr\n"));
                AtapiEnableInterrupts(deviceExtension, j);
                KdPrint2((PRINT_PREFIX "  wait a little (2)\n"));
                AtapiStallExecution(100000);
*/
                AtapiHardReset(chan, TRUE, 100000);
                KdPrint2((PRINT_PREFIX "  disable intr\n"));
                AtapiDisableInterrupts(deviceExtension, j);
                AtapiStallExecution(100);
                KdPrint2((PRINT_PREFIX "  re-enable intr\n"));
                AtapiEnableInterrupts(deviceExtension, j);
                KdPrint2((PRINT_PREFIX "  done\n"));
 
                break;
            } // end switch()
 
            //if(!(ChipFlags & UNIATA_SATA)) {}
            if(!UniataIsSATARangeAvailable(deviceExtension, j)) {
                // Reset DMA engine if active
                KdPrint2((PRINT_PREFIX "  check DMA engine\n"));
                dma_status = GetDmaStatus(chan->DeviceExtension, chan->lChannel);
                KdPrint2((PRINT_PREFIX "  DMA status %#x\n", dma_status));
                if((ChannelCtrlFlags & CTRFLAGS_DMA_ACTIVE) ||
                   (dma_status & BM_STATUS_INTR)) {
                    AtapiDmaDone(HwDeviceExtension, 0, j, NULL);
                }
            }
        } // ATA vs AHCI
 
        // all these shall be performed inside AtapiHwInitialize__() ?
#if 1
        KdPrint2((PRINT_PREFIX "  process connected devices 0 - %d\n", MaxLuns-1));
        // Do special processing for ATAPI and IDE disk devices.
        for (i = 0; i < MaxLuns; i++) {
 
            // Check if device present.
            KdPrint2((PRINT_PREFIX "  Chan %#x\n", chan));
            KdPrint2((PRINT_PREFIX "  Lun %#x\n", i));
            KdPrint2((PRINT_PREFIX "  Lun ptr %#x\n", chan->lun[i]));
            if (!(chan->lun[i]->DeviceFlags & DFLAGS_DEVICE_PRESENT)) {
                if(ChipFlags & UNIATA_AHCI) {
                    // everything is done in UniataAhciReset()
                    KdPrint2((PRINT_PREFIX "  device have gone\n"));
                    continue;
                }
#ifdef NAVO_TEST
                continue;
#else //NAVO_TEST
                //if(!CheckDevice(HwDeviceExtension, i, j, FALSE))
                if(!UniataAnybodyHome(HwDeviceExtension, j, i)) {
                    continue;
                }
                if(!CheckDevice(HwDeviceExtension, j, i, TRUE)) {
                    continue;
                }
            } else {
                if(ChipFlags & UNIATA_AHCI) {
                    // everything is done in UniataAhciReset()
                    KdPrint2((PRINT_PREFIX "  found some device\n"));
 
                    if(!IssueIdentify(HwDeviceExtension,
                                  i, j,
                             ATAPI_DEVICE(chan, i) ?
                                  IDE_COMMAND_ATAPI_IDENTIFY : IDE_COMMAND_IDENTIFY,
                                  FALSE)) {
                        KdPrint2((PRINT_PREFIX "  identify failed !\n"));
                        UniataForgetDevice(chan->lun[i]);
                    }
                    continue;
                }
                if(!UniataAnybodyHome(HwDeviceExtension, j, i)) {
                    KdPrint2((PRINT_PREFIX "  device have gone\n"));
                    UniataForgetDevice(chan->lun[i]);
                }
#endif //NAVO_TEST
            }
 
            SelectDrive(chan, i);
            AtapiStallExecution(10);
            statusByte = WaitOnBusyLong(chan);
            statusByte = UniataIsIdle(deviceExtension, statusByte);
            if(statusByte == IDE_STATUS_WRONG) {
                KdPrint2((PRINT_PREFIX
                           "no drive, status %#x\n",
                           statusByte));
                UniataForgetDevice(chan->lun[i]);
            } else
            // Check for ATAPI disk.
            if (ATAPI_DEVICE(chan, i)) {
                // Issue soft reset and issue identify.
                GetStatus(chan, statusByte);
                KdPrint2((PRINT_PREFIX "AtapiResetController: Status before Atapi reset (%#x).\n",
                            statusByte));
 
                AtapiDisableInterrupts(deviceExtension, j);
                AtapiSoftReset(chan, i);
                AtapiEnableInterrupts(deviceExtension, j);
 
                GetStatus(chan, statusByte);
 
                if(statusByte != IDE_STATUS_SUCCESS) {
                    ULONG k;
                    k = UniataAnybodyHome(deviceExtension, j, i);
                    if(k == ATA_AT_HOME_HDD) {
                        // device reset in progress, perform additional wait
                        KdPrint2((PRINT_PREFIX "  long reset, wait up to 4.5 s\n"));
                        k = 30 * 1000;
                        while ((AtapiReadPort1(chan, IDX_IO1_i_Status) & IDE_STATUS_BUSY) &&
                               k--)
                        {
                            AtapiStallExecution(150);
                        }
                        KdPrint2((PRINT_PREFIX " exit after %u loops\n", k));
                        GetStatus(chan, statusByte);
                    }
                }
                if(statusByte == IDE_STATUS_SUCCESS) {
 
                    IssueIdentify(HwDeviceExtension,
                                  i, j,
                                  IDE_COMMAND_ATAPI_IDENTIFY, FALSE);
                } else {
 
                    KdPrint2((PRINT_PREFIX
                               "AtapiResetController: Status after soft reset %#x\n",
                               statusByte));
                }
                GetBaseStatus(chan, statusByte);
 
            } else {
                // Issue identify and reinit after channel reset.
 
                if (statusByte != IDE_STATUS_IDLE &&
                    statusByte != IDE_STATUS_SUCCESS &&
                    statusByte != IDE_STATUS_DRDY) {
//                    result2 = FALSE;
                    KdPrint2((PRINT_PREFIX "AtapiResetController: IdeHardReset failed\n"));
                } else
                if(!IssueIdentify(HwDeviceExtension,
                                  i, j,
                                  IDE_COMMAND_IDENTIFY, FALSE)) {
//                    result2 = FALSE;
                    KdPrint2((PRINT_PREFIX "AtapiResetController: IDE IssueIdentify failed\n"));
                } else
                // Set disk geometry parameters.
                if (!SetDriveParameters(HwDeviceExtension, i, j)) {
                    KdPrint2((PRINT_PREFIX "AtapiResetController: SetDriveParameters failed\n"));
                }
                GetBaseStatus(chan, statusByte);
            }
            // force DMA mode reinit
            KdPrint2((PRINT_PREFIX " set DFLAGS_REINIT_DMA\n"));
            chan->lun[i]->DeviceFlags |= DFLAGS_REINIT_DMA;
        }
#endif //0
 
        // Enable interrupts, note, we can have here recursive disable
        AtapiStallExecution(10);
        KdPrint2((PRINT_PREFIX "AtapiResetController: deviceExtension->chan[%d].DisableIntr %d -> 1\n",
            j,
            chan->DisableIntr));
        AtapiEnableInterrupts(deviceExtension, j);
 
        // Call the HwInitialize routine to setup multi-block.
        AtapiHwInitialize__(deviceExtension, j);
    } // for(channel)
    ScsiPortNotification(NextRequest, deviceExtension, NULL);
 
    return TRUE;
 
} // end AtapiResetController__()
 
 
/*++
 
Routine Description:
    This routine maps ATAPI and IDE errors to specific SRB statuses.
 
Arguments:
    HwDeviceExtension - HBA miniport driver's adapter data storage
    Srb - IO request packet
 
Return Value:
    SRB status
 
--*/
ULONG
NTAPI
MapError(
    IN PVOID HwDeviceExtension,
    IN PSCSI_REQUEST_BLOCK Srb
    )
{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    ULONG lChannel = GET_CHANNEL(Srb);
    PHW_CHANNEL chan = &(deviceExtension->chan[lChannel]);
//    ULONG i;
    UCHAR errorByte = 0;
    UCHAR srbStatus = SRB_STATUS_SUCCESS;
    UCHAR scsiStatus;
    ULONG DeviceNumber = GET_CDEV(Srb);
    PHW_LU_EXTENSION     LunExt = chan->lun[DeviceNumber];
 
    // Read the error register.
 
    if(deviceExtension->HwFlags & UNIATA_AHCI) {
        PATA_REQ AtaReq = (PATA_REQ)(Srb->SrbExtension);
        if(AtaReq) {
            errorByte = AtaReq->ahci.in_error;
        } else {
        }
    } else {
        errorByte = AtapiReadPort1(chan, IDX_IO1_i_Error);
    }
    KdPrint2((PRINT_PREFIX
               "MapError: Error register is %#x\n",
               errorByte));
 
    if (LunExt->DeviceFlags & DFLAGS_ATAPI_DEVICE) {
 
        switch (errorByte >> 4) {
        case SCSI_SENSE_NO_SENSE:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: No sense information\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_RECOVERED_ERROR:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Recovered error\n"));
            scsiStatus = 0;
            srbStatus = SRB_STATUS_SUCCESS;
            break;
 
        case SCSI_SENSE_NOT_READY:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Device not ready\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_MEDIUM_ERROR:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Media error\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_HARDWARE_ERROR:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Hardware error\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_ILLEGAL_REQUEST:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Illegal request\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_UNIT_ATTENTION:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Unit attention\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_DATA_PROTECT:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Data protect\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_BLANK_CHECK:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Blank check\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        case SCSI_SENSE_ABORTED_COMMAND:
            KdPrint2((PRINT_PREFIX
                        "Atapi: Command Aborted\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
            break;
 
        default:
 
            KdPrint2((PRINT_PREFIX
                       "ATAPI: Invalid sense information\n"));
            scsiStatus = 0;
            srbStatus = SRB_STATUS_ERROR;
            break;
        }
 
    } else {
 
        scsiStatus = 0;
 
        // Save errorByte,to be used by SCSIOP_REQUEST_SENSE.
        chan->ReturningMediaStatus = errorByte;
 
        if (errorByte & IDE_ERROR_MEDIA_CHANGE_REQ) {
            KdPrint2((PRINT_PREFIX
                       "IDE: Media change\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
 
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_MEDIUM_CHANGED;
                senseBuffer->AdditionalSenseCodeQualifier = 0;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
 
        } else if (errorByte & IDE_ERROR_COMMAND_ABORTED) {
            KdPrint2((PRINT_PREFIX
                       "IDE: Command abort\n"));
            srbStatus = SRB_STATUS_ABORTED;
            scsiStatus = SCSISTAT_CHECK_CONDITION;
 
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_ABORTED_COMMAND;
                senseBuffer->AdditionalSenseCode = 0;
                senseBuffer->AdditionalSenseCodeQualifier = 0;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
 
            LunExt->ErrorCount++;
 
        } else if (errorByte & IDE_ERROR_END_OF_MEDIA) {
 
            KdPrint2((PRINT_PREFIX
                       "IDE: End of media\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
 
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_MEDIA_STATE;
                senseBuffer->AdditionalSenseCodeQualifier = SCSI_SENSEQ_END_OF_MEDIUM;
                senseBuffer->EndOfMedia = 1;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
 
            if (!(LunExt->DeviceFlags & DFLAGS_MEDIA_STATUS_ENABLED)){
                LunExt->ErrorCount++;
            }
 
        } else if (errorByte & IDE_ERROR_ILLEGAL_LENGTH) {
 
            KdPrint2((PRINT_PREFIX
                       "IDE: Illegal length\n"));
            srbStatus = SRB_STATUS_INVALID_REQUEST;
 
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_ILLEGAL_REQUEST;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_INVALID_VALUE;
                senseBuffer->AdditionalSenseCodeQualifier = SCSI_SENSEQ_PARAM_INVALID_VALUE;
                senseBuffer->IncorrectLength = 1;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
 
        } else if (errorByte & IDE_ERROR_BAD_BLOCK) {
 
            KdPrint2((PRINT_PREFIX
                       "IDE: Bad block\n"));
            srbStatus = SRB_STATUS_ERROR;
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_MEDIUM_ERROR;
                senseBuffer->AdditionalSenseCode = 0;
                senseBuffer->AdditionalSenseCodeQualifier = 0;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
 
        } else if (errorByte & IDE_ERROR_ID_NOT_FOUND) {
 
            KdPrint2((PRINT_PREFIX
                       "IDE: Id not found\n"));
            srbStatus = SRB_STATUS_ERROR;
            scsiStatus = SCSISTAT_CHECK_CONDITION;
 
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_MEDIUM_ERROR;
                senseBuffer->AdditionalSenseCode = 0;
                senseBuffer->AdditionalSenseCodeQualifier = 0;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
 
            LunExt->ErrorCount++;
 
        } else if (errorByte & IDE_ERROR_MEDIA_CHANGE) {
 
            KdPrint2((PRINT_PREFIX
                       "IDE: Media change\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
 
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_UNIT_ATTENTION;
                senseBuffer->AdditionalSenseCode = SCSI_ADSENSE_MEDIUM_CHANGED;
                senseBuffer->AdditionalSenseCodeQualifier = 0;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
 
        } else if (errorByte & IDE_ERROR_DATA_ERROR) {
 
            KdPrint2((PRINT_PREFIX
                   "IDE: Data error\n"));
            scsiStatus = SCSISTAT_CHECK_CONDITION;
            srbStatus = SRB_STATUS_ERROR;
 
            if (!(LunExt->DeviceFlags & DFLAGS_MEDIA_STATUS_ENABLED)){
                LunExt->ErrorCount++;
            }
 
            // Build sense buffer
            if (Srb->SenseInfoBuffer) {
 
                PSENSE_DATA  senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
                senseBuffer->ErrorCode = 0x70;
                senseBuffer->Valid     = 1;
                senseBuffer->AdditionalSenseLength = 0xb;
                senseBuffer->SenseKey =  SCSI_SENSE_MEDIUM_ERROR;
                senseBuffer->AdditionalSenseCode = 0;
                senseBuffer->AdditionalSenseCodeQualifier = 0;
 
                srbStatus |= SRB_STATUS_AUTOSENSE_VALID;
            }
        }
 
        if (LunExt->ErrorCount >= MAX_ERRORS) {
//            deviceExtension->DWordIO = FALSE;
 
            KdPrint2((PRINT_PREFIX
                        "MapError: ErrorCount >= MAX_ERRORS\n"));
 
            LunExt->DeviceFlags &= ~DFLAGS_DWORDIO_ENABLED;
            LunExt->MaximumBlockXfer = 0;
            BrutePoint();
 
            KdPrint2((PRINT_PREFIX
                        "MapError: Disabling 32-bit PIO and Multi-sector IOs\n"));
 
            // Log the error.
            KdPrint2((PRINT_PREFIX
                        "ScsiPortLogError: devExt %#x, Srb %#x, P:T:D=%d:%d:%d, MsgId %#x (%d)\n",
                              HwDeviceExtension,
                              Srb,
                              Srb->PathId,
                              Srb->TargetId,
                              Srb->Lun,
                              SP_BAD_FW_WARNING,
                              4
                        ));
            ScsiPortLogError( HwDeviceExtension,
                              Srb,
                              Srb->PathId,
                              Srb->TargetId,
                              Srb->Lun,
                              SP_BAD_FW_WARNING,
                              4);
 
            // Reprogram to not use Multi-sector.
            UCHAR statusByte;
 
            if (LunExt->DeviceFlags & DFLAGS_DEVICE_PRESENT &&
                 !(LunExt->DeviceFlags & (DFLAGS_ATAPI_DEVICE | DFLAGS_MANUAL_CHS))) {
 
                statusByte = AtaCommand(deviceExtension, DeviceNumber, lChannel, IDE_COMMAND_SET_MULTIPLE, 0, 0, 0, 0, 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 "MapError: Error setting multiple mode. Status %#x, error byte %#x\n",
                                statusByte,
                                errorByte));
 
                    // Adjust the devExt. value, if necessary.
                    LunExt->MaximumBlockXfer = 0;
                    BrutePoint();
 
                }
            }
        }
    }
 
    // Set SCSI status to indicate a check condition.
    Srb->ScsiStatus = scsiStatus;
 
    return srbStatus;
 
} // end MapError()
 
 
/*++
 
Routine Description:
 
Arguments:
    HwDeviceExtension - HBA miniport driver's adapter data storage
    ->HwInitialize
 
Return Value:
    TRUE - if initialization successful.
    FALSE - if initialization unsuccessful.
 
--*/
BOOLEAN
NTAPI
AtapiHwInitialize(
    IN PVOID HwDeviceExtension
    )
{
    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()
 
VOID
NTAPI
AtapiHwInitialize__(
    IN PHW_DEVICE_EXTENSION deviceExtension,
    IN ULONG lChannel
    )
{
    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__()
 
 
#ifndef UNIATA_CORE
 
VOID
NTAPI
AtapiHwInitializeChanger(
    IN PVOID HwDeviceExtension,
    IN PSCSI_REQUEST_BLOCK Srb,
    IN PMECHANICAL_STATUS_INFORMATION_HEADER MechanismStatus)
{
    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()
 
 
/*++
 
Routine Description:
    This routine will parse the string for a match on the keyword, then
    calculate the value for the keyword and return it to the caller.
 
Arguments:
    String - The ASCII string to parse.
    KeyWord - The keyword for the value desired.
 
Return Values:
    Zero if value not found
    Value converted from ASCII to binary.
 
--*/
ULONG
NTAPI
AtapiParseArgumentString(
    IN PCCH String,
    IN PCCH KeyWord
    )
{
    PCCH cptr;
    PCCH kptr;
    ULONG value;
    ULONG stringLength = 0;
    ULONG keyWordLength = 0;
    ULONG index;
 
    if (!String) {
        return 0;
    }
    if (!KeyWord) {
        return 0;
    }
 
    // Calculate the string length and lower case all characters.
    cptr = String;
    while (*cptr++) {
        stringLength++;
    }
 
    // Calculate the keyword length.
    kptr = KeyWord;
    while (*kptr++) {
        keyWordLength++;
    }
 
    if (keyWordLength > stringLength) {
 
        // Can't possibly have a match.
        return 0;
    }
 
    // Now setup and start the compare.
    cptr = String;
 
ContinueSearch:
 
    // The input string may start with white space.  Skip it.
    while (*cptr == ' ' || *cptr == '\t') {
        cptr++;
    }
 
    if (*cptr == '\0') {
        // end of string.
        return 0;
    }
 
    kptr = KeyWord;
    while ((*cptr == *kptr) ||
           (*cptr >= 'A' && *cptr <= 'Z' && *cptr + ('a' - 'A') == *kptr) ||
           (*cptr >= 'a' && *cptr <= 'z' && *cptr - ('a' - 'A') == *kptr)) {
        cptr++;
        kptr++;
 
        if (*cptr == '\0') {
            // end of string
            return 0;
        }
    }
 
    if (*kptr == '\0') {
 
        // May have a match backup and check for blank or equals.
        while (*cptr == ' ' || *cptr == '\t') {
            cptr++;
        }
 
        // Found a match.  Make sure there is an equals.
        if (*cptr != '=') {
 
            // Not a match so move to the next semicolon.
            while (*cptr) {
                if (*cptr++ == ';') {
                    goto ContinueSearch;
                }
            }
            return 0;
        }
        // Skip the equals sign.
        cptr++;
 
        // Skip white space.
        while ((*cptr == ' ') || (*cptr == '\t')) {
            cptr++;
        }
 
        if (*cptr == '\0') {
            // Early end of string, return not found
            return 0;
        }
 
        if (*cptr == ';') {
            // This isn't it either.
            cptr++;
            goto ContinueSearch;
        }
 
        value = 0;
        if ((*cptr == '0') && ((*(cptr + 1) == 'x') || (*(cptr + 1) == 'X'))) {
            // Value is in Hex.  Skip the "0x"
            cptr += 2;
            for (index = 0; *(cptr + index); index++) {
 
                if (*(cptr + index) == ' ' ||
                    *(cptr + index) == '\t' ||
                    *(cptr + index) == ';') {
                     break;
                }
 
                if ((*(cptr + index) >= '0') && (*(cptr + index) <= '9')) {
                    value = (16 * value) + (*(cptr + index) - '0');
                } else {
                    if ((*(cptr + index) >= 'a') && (*(cptr + index) <= 'f')) {
                        value = (16 * value) + (*(cptr + index) - 'a' + 10);
                    } else if ((*(cptr + index) >= 'A') && (*(cptr + index) <= 'F')) {
                        value = (16 * value) + (*(cptr + index) - 'A' + 10);
                    } else {
                        // Syntax error, return not found.
                        return 0;
                    }
                }
            }
        } else {
 
            // Value is in Decimal.
            for (index = 0; *(cptr + index); index++) {
 
                if (*(cptr + index) == ' ' ||
                    *(cptr + index) == '\t' ||
                    *(cptr + index) == ';') {
                     break;
                }
 
                if ((*(cptr + index) >= '0') && (*(cptr + index) <= '9')) {
                    value = (10 * value) + (*(cptr + index) - '0');
                } else {
 
                    // Syntax error return not found.
                    return 0;
                }
            }
        }
 
        return value;
    } else {
 
        // Not a match check for ';' to continue search.
        while (*cptr) {
            if (*cptr++ == ';') {
                goto ContinueSearch;
            }
        }
 
        return 0;
    }
} // end AtapiParseArgumentString()_
 
/*
    Timer callback
*/
VOID
NTAPI
AtapiCallBack__(
    IN PVOID HwDeviceExtension,
    IN UCHAR lChannel
    )
{
 
    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__()
 
VOID
NTAPI
AtapiCallBack_X(
    IN PVOID HwDeviceExtension
    )
{
    AtapiCallBack__(HwDeviceExtension, (UCHAR)((PHW_DEVICE_EXTENSION)HwDeviceExtension)->ActiveDpcChan);
} // end AtapiCallBack_X()
 
#endif //UNIATA_CORE
 
/*++
 
Routine Description:
 
    This is the interrupt service routine for ATAPI IDE miniport driver.
 
Arguments:
 
    HwDeviceExtension - HBA miniport driver's adapter data storage
 
Return Value:
 
    TRUE if expecting an interrupt.
 
--*/
BOOLEAN
NTAPI
AtapiInterrupt(
    IN PVOID HwDeviceExtension
    )
{
    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()
 
//ULONG i2c = 0;
#ifndef UNIATA_CORE
 
BOOLEAN
NTAPI
AtapiInterrupt2(
    IN PKINTERRUPT Interrupt,
    IN PVOID Isr2HwDeviceExtension
    )
{
    // 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()
 
RETTYPE_XXableInterrupts
NTAPI
AtapiInterruptDpc(
    IN PVOID HwDeviceExtension
    )
{
    PHW_DEVICE_EXTENSION deviceExtension = (PHW_DEVICE_EXTENSION)HwDeviceExtension;
    ULONG c;
 
    for(c=0; c<deviceExtension->NumberChannels; c++) {
        KdPrint2((PRINT_PREFIX "AtapiInterruptDpc: %#x\n",c));
 
        if(!(deviceExtension->chan[c].ChannelCtrlFlags & CTRFLAGS_DPC_REQ)) {
 
            if((ULONG)CrNtInterlockedCompareExchange(CRNT_ILK_PTYPE &(deviceExtension->chan[c].CheckIntr),
                                          CRNT_ILK_TYPE CHECK_INTR_ACTIVE,
                                          CRNT_ILK_TYPE CHECK_INTR_DETECTED) != CHECK_INTR_DETECTED)
            {
                continue;
            }
 
        } else {
            deviceExtension->chan[c].ChannelCtrlFlags &= ~CTRFLAGS_DPC_REQ;
        }
/*
        if(OldReqState != REQ_STATE_DPC_INTR_REQ) {
            AtapiDisableInterrupts(deviceExtension, lChannel);
        }
*/
        deviceExtension->chan[c].DpcState = DPC_STATE_DPC;
        if(!AtapiInterrupt__(HwDeviceExtension, (UCHAR)c)) {
            InterlockedExchange(&(deviceExtension->chan[c].CheckIntr), CHECK_INTR_IDLE);
        }
    }
    return RETVAL_XXableInterrupts;
} // end AtapiInterruptDpc()
 
 
RETTYPE_XXableInterrupts
NTAPI
AtapiEnableInterrupts__(
    IN PVOID HwDeviceExtension
    )
{
    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) {