ep931xide.cpp

CIRRUS 公司EP93XX系列CPU的WINCE下的BSP

        //
        // Set the DMA state to false.
        //
        m_bDMAState = FALSE;
    }
}




//****************************************************************************
// CEP931xPort::DumpDmaState
//****************************************************************************
// Dumps the Dma state machine 
// 
//
void CEP931xPort::DumpDmaState(void)
{
    NKDbgPrintfW( L"    M2M_CTRL         = 0x%08x\r\n", m_pulDmaBase[M2M_CTRL>>2]);
    NKDbgPrintfW( L"    M2M_INT          = 0x%08x\r\n", m_pulDmaBase[M2M_INT>>2]);
    NKDbgPrintfW( L"    M2M_STATUS       = 0x%08x\r\n", m_pulDmaBase[M2M_STATUS>>2]);
    NKDbgPrintfW( L"    M2M_BCR0         = 0x%08x\r\n", m_pulDmaBase[M2M_BCR0>>2]);
    NKDbgPrintfW( L"    M2M_BCR1         = 0x%08x\r\n", m_pulDmaBase[M2M_BCR1>>2]);
    NKDbgPrintfW( L"    M2M_SAR_BASE0    = 0x%08x\r\n", m_pulDmaBase[M2M_SAR_BASE0>>2]);
    NKDbgPrintfW( L"    M2M_SAR_BASE1    = 0x%08x\r\n", m_pulDmaBase[M2M_SAR_BASE1>>2]);
    NKDbgPrintfW( L"    M2M_SAR_CURRENT0 = 0x%08x\r\n", m_pulDmaBase[M2M_SAR_CURRENT0>>2]);
    NKDbgPrintfW( L"    M2M_SAR_CURRENT1 = 0x%08x\r\n", m_pulDmaBase[M2M_SAR_CURRENT1>>2]);
    NKDbgPrintfW( L"    M2M_DAR_BASE0    = 0x%08x\r\n", m_pulDmaBase[M2M_DAR_BASE0>>2]);
    NKDbgPrintfW( L"    M2M_DAR_BASE1    = 0x%08x\r\n", m_pulDmaBase[M2M_DAR_BASE1>>2]);
    NKDbgPrintfW( L"    M2M_DAR_CURRENT0 = 0x%08x\r\n", m_pulDmaBase[M2M_DAR_CURRENT0>>2]);
    NKDbgPrintfW( L"    M2M_DAR_CURRENT1 = 0x%08x\r\n", m_pulDmaBase[M2M_DAR_CURRENT1>>2]);
}
//****************************************************************************
// CEP931xPort::DumpIDEState
//****************************************************************************
// 
// 
//
void CEP931xPort::DumpIDEState(void)
{
    NKDbgPrintfW(L"    IDE_CTRL         = 0x%08x\r\n", *IDE_CTRL);
    NKDbgPrintfW(L"    IDE_CFG          = 0x%08x\r\n", *IDE_CFG);
    NKDbgPrintfW(L"    IDE_MDMAOP       = 0x%08x\r\n", *IDE_MDMAOP);
    NKDbgPrintfW(L"    IDE_UDMAOP       = 0x%08x\r\n", *IDE_UDMAOP);
    NKDbgPrintfW(L"    IDE_UDMASTATUS   = 0x%08x\r\n", *IDE_UDMASTATUS);
    NKDbgPrintfW(L"    IDE_UDMADEBUG    = 0x%08x\r\n", *IDE_UDMADEBUG);
    NKDbgPrintfW(L"    IDE_UDMAWFST     = 0x%08x\r\n", *IDE_UDMAWFST);
    NKDbgPrintfW(L"    IDE_UDMARFST     = 0x%08x\r\n", *IDE_UDMARFST);
}


//****************************************************************************
// CEP931xDisk::CEP931xDisk
//****************************************************************************
// Constructor.
// 
//
CEP931xDisk::CEP931xDisk
(
    CEP931xPort *pPort, 
    HKEY    hDevKey
):  CDisk(hDevKey), 
    m_pPort(pPort), 
    m_fForcePIO(FALSE)
{

    //
    // We support interrupts and are a 16 bit device.
    //
    m_f16Bit = TRUE;
    m_fInterruptSupported = TRUE;

    //
    // Clear the counters for the Dma Statistics.
    //
    memset((void *)&m_DmaStatistics, 0, sizeof(m_DmaStatistics));
}

//****************************************************************************
// CEP931xDisk::Init
//****************************************************************************
// Initialization function for CEP931xDisk
// 
//
BOOL CEP931xDisk::Init(HKEY hActiveKey)
{

    BOOL bRet;
    int ThreadPriority;
    static int IterationCount = 0;

    //  Retrieve DeviceID  Number from Registry (0,1,2,3,4,5,6,7).
    //   A Device is specified by three Bits:
    //      Bit 0 - Specify Device on the chanel/port. Master(0)/Slave(1)
    //      Bit 1 - Specify Port/Channel: 0- Primary, 1 - Secondary Port
    //      Bit 3 - Specify Ata Controller/Adapter.
    //
    bRet = AtaGetRegistryValue(m_hDevKey, TEXT("DeviceId"), &m_dwDeviceId);
    
    if(!bRet)
    {
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPIPCI:Init: Missing Device Number in Registry \r\n")));
    }

    //
    // Verify that the DeviceID is in range
    //
    if ((m_dwDeviceId <0) || (m_dwDeviceId >= MAX_ATA_DEVICES))
    {
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPIPCI:Init: Wrong DeviceID in the Registry DeviceId=% \r\n"),m_dwDeviceId));
        bRet = FALSE;
    }

    if(bRet)
    {    
        //
        // Now can configure Port if not configure yet. 
        //
        m_dwDevice = m_dwDeviceId & 1;

        
        //
        // Initialize the base class.
        //
        bRet = CDisk::Init(hActiveKey);
        
        if (bRet == 1)
            ++IterationCount;
    }

    //CeSetThreadPriority(GetCurrentThread(), 15);

    ThreadPriority = CeGetThreadPriority(GetCurrentThread());
    DEBUGMSG ( ZONE_INIT, (TEXT("* * * CEP931xDisk thread priority = %d * * *\r\n"),ThreadPriority));

    //
    // Keep this commented out because it will erase your boot sector on the    
    // hard drive.
    //
    // TestRoutines();


    return bRet;
}


//****************************************************************************
// CEP931xDisk::GetBaseStatus
//****************************************************************************
// 
// 
//
BYTE CEP931xDisk::GetBaseStatus()
{
    return(BYTE(ATAReadRegister(CSDA_STAT_REG) & 0xFF));
}

//****************************************************************************
// CEP931xDisk::GetAltStatus
//****************************************************************************
// 
// 
//
BYTE CEP931xDisk::GetAltStatus()
{
    return(BYTE(ATAReadRegister(CSDA_ALT_STAT_REG) & 0xFF));
}

//****************************************************************************
// CEP931xDisk::GetError
//****************************************************************************
// 
// 
//
BYTE CEP931xDisk::GetError()
{
    return(BYTE(ATAReadRegister(CSDA_ERROR_REG) & 0xFF));
}

//****************************************************************************
// CEP931xDisk::GetReason
//****************************************************************************
// 
// 
//
BYTE CEP931xDisk::GetReason()
{
    return(BYTE(ATAReadRegister(CSDA_REASON_REG) & 0xFF));
}

//****************************************************************************
// CEP931xDisk::SelectDevice
//****************************************************************************
// 
// 
//
void CEP931xDisk::SelectDevice()
{
    ATAWriteRegister
    (
        CSDA_DRVHD_REG, 
        (m_dwDevice == 0 ) ? ATA_HEAD_DRIVE_1 : ATA_HEAD_DRIVE_2
    );
}

//****************************************************************************
// CEP931xDisk::WriteDriveController
//****************************************************************************
// Currently the only reason to write the Drive Controller or the alternate 
// Drive Controller is to enable the interrupt.  On the EP931x the interrupt is 
// always enabled inside the conntroller.
// 
//
void CEP931xDisk::WriteDriveController(BYTE bData)
{
    ATAWriteRegister(CSDA_ALT_CTRL_REG, (ULONG) bData);
}

//****************************************************************************
// CEP931xDisk::WriteAltDriveController
//****************************************************************************
// Currently the only reason to write the Drive Controller or the alternate 
// Drive Controller is to enable the interrupt.  On the EP931x the interrupt is 
// always enabled inside the conntroller.
//
void CEP931xDisk::WriteAltDriveController(BYTE bData)
{
    ATAWriteRegister(CSDA_ALT_CTRL_REG, (ULONG) bData);
}

//****************************************************************************
// CEP931xDisk::SetDriveHead
//****************************************************************************
// 
// 
//
void CEP931xDisk::SetDriveHead(BYTE bDriveHead)
{
    ATAWriteRegister(CSDA_DRVHD_REG, (ULONG) bDriveHead);
}

//****************************************************************************
// CEP931xDisk::WriteCommand
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteCommand(BYTE bCommand)
{
    ATAWriteRegister(CSDA_CMD_REG, (ULONG) bCommand);
}

//****************************************************************************
// CEP931xDisk::WriteFeature
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteFeature(BYTE bFeature)
{
    ATAWriteRegister(CSDA_FEATURE_REG, (ULONG) bFeature);
}
//****************************************************************************
// CEP931xDisk::WriteSectorCount
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteSectorCount(BYTE bValue)
{
    ATAWriteRegister(CSDA_SECTCNT_REG, (ULONG) bValue);
}
//****************************************************************************
// CEP931xDisk::WriteDriveHeadReg
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteDriveHeadReg(BYTE bValue)
{
    ATAWriteRegister(CSDA_DRVHD_REG, (ULONG) bValue);
}
//****************************************************************************
// CEP931xDisk::WriteSectorNumber
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteSectorNumber(BYTE bValue)
{
    ATAWriteRegister(CSDA_SECTNUM_REG, (ULONG) bValue);
}
//****************************************************************************
// CEP931xDisk::WriteLowCount
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteLowCount(BYTE bValue)
{
    ATAWriteRegister(CSDA_CYLL_REG, (ULONG) bValue);
}
//****************************************************************************
// CEP931xDisk::WriteHighCount
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteHighCount(BYTE bValue)
{
    ATAWriteRegister(CSDA_CYLH_REG, (ULONG) bValue);
}
//****************************************************************************
// CEP931xDisk::GetLowCount
//****************************************************************************
// 
// 
//
BYTE CEP931xDisk::GetLowCount()
{
    return ((BYTE) (ATAReadRegister(CSDA_CYLL_REG) & 0xFF));
}
//****************************************************************************
// CEP931xDisk::GetHighCount
//****************************************************************************
// 
// 
//
BYTE CEP931xDisk::GetHighCount()
{
    return ((BYTE) (ATAReadRegister(CSDA_CYLH_REG) & 0xFF));
}


//****************************************************************************
// CEP931xDisk::ReadWordBuffer
//****************************************************************************
// 
// 
//
void CEP931xDisk::ReadWordBuffer( PWORD pBuffer, DWORD dwCount)
{
    PWORD pEnd;
    pEnd = pBuffer + dwCount;

    while(pBuffer < pEnd)
    {
        *pBuffer++ = (WORD)(ATAReadRegister(CSDA_DATA_REG) & 0xFFFF);
    }

}
//****************************************************************************
// CEP931xDisk::WriteWordBuffer
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteWordBuffer( PWORD pBuffer, DWORD dwCount)
{
    PWORD pEnd;
    pEnd = pBuffer + dwCount;

    while(pBuffer < pEnd)
    {
        ATAWriteRegister(CSDA_DATA_REG, (ULONG)(*pBuffer++));
    }
}
//****************************************************************************
// CEP931xDisk::ReadByteBuffer
//****************************************************************************
// 
// 
//
void CEP931xDisk::ReadByteBuffer( PBYTE pBuffer, DWORD dwCount)
{
    DWORD   dwIndex;
    for(dwIndex = 0 ; dwIndex < dwCount ; dwIndex++)
    {
        pBuffer[dwIndex] = (BYTE)(ATAReadRegister(CSDA_DATA_REG) & 0xFF);
    }
}
//****************************************************************************
// CEP931xDisk::WriteByteBuffer
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteByteBuffer( PBYTE pBuffer, DWORD dwCount)
{
    DWORD   dwIndex;
    for(dwIndex = 0 ; dwIndex < dwCount ; dwIndex++)
    {
        ATAWriteRegister(CSDA_DATA_REG, (ULONG)pBuffer[dwIndex]);
    }
}
//****************************************************************************
// CEP931xDisk::WriteWord
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteWord(WORD wData)
{
    ATAWriteRegister(CSDA_DATA_REG, (ULONG)wData);
}
//****************************************************************************
// CEP931xDisk::ReadWord
//****************************************************************************
// 
// 
//
WORD CEP931xDisk::ReadWord()
{
    return ((WORD)(ATAReadRegister(CSDA_DATA_REG) & 0xFFFF));
}
//****************************************************************************
// CEP931xDisk::WriteByte
//****************************************************************************
// 
// 
//
void CEP931xDisk::WriteByte(BYTE bData)
{
    ATAWriteRegister(CSDA_DATA_REG, (ULONG)bData);
}
//****************************************************************************
// CEP931xDisk::ReadByte
//****************************************************************************
// 
// 
//
WORD CEP931xDisk::ReadByte()
{
    return ((BYTE)(ATAReadRegister(CSDA_DATA_REG) & 0xFF));
}

//****************************************************************************
// CEP931xDisk::WaitForInterrupt
//****************************************************************************
// Waits for the IDE interrupt.  This is used for waiting in PIO mode.
//
// dwTimeOut - Time out in mS
// 
// Return      TRUE  - Success
//             FALSE - Failure
//          
BOOL CEP931xDisk::WaitForInterrupt(DWORD dwTimeOut)
{
    BYTE    bStatus;