ep931xide.cpp

EP931X系列的WinCE显卡驱动源代码

        )
    );

    //
    // Unlock the Buffers and free the mapped pointers.
    //
    if(m_fAligned)
    {
        fRet = UnlockPages
        ( 
            m_pucDmaBuffer,
            m_ulDmaCount
        );
        ASSERT(fRet);
    }

    //
    // If the pSgBuf are unaligned, copy the entire buffer to our buffer.
    //
    else if(!m_fAligned && fRead)
    {
        ulDmaCount        = 0;
        for (ulBuffer = 0; ulBuffer < dwSgCount; ulBuffer++) 
        {
            pBuffer = (LPBYTE)MapPtrToProcess(pSgBuf[ulBuffer].sb_buf, GetCallerProcess());
            memcpy(pBuffer, m_pucDmaBuffer + ulDmaCount, pSgBuf[ulBuffer].sb_len);
            ulDmaCount+= pSgBuf[ulBuffer].sb_len;
        }
    }

    return fRet;
}

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

    if(m_bDMAState)
    {
        //
        // Disable the dma.
        //
        *IDE_MDMAOP =  0;
        *IDE_UDMAOP =  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)  
{

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

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

    BOOL bRet;

    //  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);
    }

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