ep931xide.cpp

EP9315开发板的Wince6.0的BSP包文件

                memcpy(pBuffer, m_pucDmaBuffer + ulDmaCount, pSgBuf[ulBuffer].sb_len);
            }

            ulDmaCount+= pSgBuf[ulBuffer].sb_len;
        }
    //RETAILMSG( 1, (TEXT("    Unaligned copy in CompleteDMA.\r\n")));

    //QueryPerformanceCounter(&liEnd);

    //liCurrent.QuadPart = (liEnd.QuadPart - liStart.QuadPart);
    //RETAILMSG ( 1, (TEXT("It took %ld uS for CompleteDMA to complete.\r\n"),liCurrent.QuadPart));
    }

    return fRet;
}

//****************************************************************************
// CEP931xDisk::PIOMode
//****************************************************************************
// PIO mode.
// 
//
void CEP931xPort::PIOMode(void)
{

    if(m_bDMAState)
    {

        //
        // Make sure there are no glitches involving CS0 or CS1 and STOP/DIOWn
        // when switching modes:  deassert CS0 and CS1.
        //
        *IDE_CTRL |= IDE_CTRL_CS0 | IDE_CTRL_CS1;

        //
        // Disable the dma.
        //
        *IDE_MDMAOP =  0;
        *IDE_UDMAOP =  0;

        //
        // Reset the UDMA state machine.
        //
        *IDE_UDMADEBUG = UDMADEBUG_RWOE | UDMADEBUG_RWPTR | UDMADEBUG_RWDR | UDMADEBUG_RROE | UDMADEBUG_RRPTR | UDMADEBUG_RRDR ;
        *IDE_UDMADEBUG = 0;


        //
        // Disable the IDE channel.
        //
        *IDE_CFG    = IDE_CFG_IDEEN | IDE_CFG_PIOEN | IDE_CFG_PIO4 | (1 <<IDE_CFG_WST_SHIFT);

        //
        // 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
//****************************************************************************
// 
//