ep931xide.cpp

Cirrus EP9315 wince bsp

// 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
//****************************************************************************
// 
// 
//
BOOL CEP931xDisk::WaitForInterrupt(DWORD dwTimeOut)
{
    BYTE bStatus;
    BOOL fRet = TRUE;
    DWORD dwRet;
    volatile register ULONG           ulIdeCtrl;

    //* * * Original (START)
	dwRet = WaitForSingleObject( m_pPort->m_hIdeIntEvent, dwTimeOut);
	ResetEvent (m_pPort->m_hIdeIntEvent);

	//* * * Short circuit the POOR IRQ stuff. (START)
    //* * * Int's are unrelaible when a slave CD/DVD drive is attached.
	if (dwTimeOut <= 0)
		dwRet = WAIT_OBJECT_0;
	//* * * Short circuit the POOR IRQ stuff. (END)	

    //
    // Temporary code.
    //
    if (dwRet == WAIT_TIMEOUT && m_pPort->m_bDMAState) 
    {
		DEBUGMSG( ZONE_WARNING, (TEXT("ATAPI:ReadCdRom- WaitforInterrupt failed * * * dwRet == WAIT_TIMEOUT (DevId %x) \r\n"),m_dwDeviceId));
        m_pPort->DumpDmaState();
        m_pPort->DumpIDEState();
    }

    //
    // If we are currently using DMA, switch to PIO mode to read the
    // registers.
    //

    m_pPort->PIOMode();

    if (dwRet == WAIT_TIMEOUT) 
    {
        fRet = FALSE;
    } 
    else if (dwRet != WAIT_OBJECT_0 && dwTimeOut >0) 
    {
        if (!WaitForDisc( WAIT_TYPE_DRQ,  dwTimeOut, 10)) 
        {
            fRet = FALSE;
        }   
    }

    //
    // Ack interrupt!!!!!
    //
    bStatus = GetBaseStatus();
    
    if (bStatus & ATA_STATUS_ERROR) 
    {
        bStatus = GetError();
        fRet = FALSE;
    }    

    InterruptDone(SYSINTR_IDE);

    return fRet;
} 

//****************************************************************************
// CEP931xDisk::EnableInterrupt
//****************************************************************************
// 
// 
//
void CEP931xDisk::EnableInterrupt()
{
	GetBaseStatus();// Ack interrupt!!!!!
	InterruptDone(SYSINTR_IDE);        
}

#define ATA_DMA_ULTRA_MODE      0x40
//****************************************************************************
// CEP931xDisk::SetBestTransferMode
//****************************************************************************
// Sets the Best Transfer mode based on the registry and the device 
// specifcations.
// 
//
void CEP931xDisk::SetBestTransferMode()
{
    ULONG   ulMwDmaMode, ulUDmaMode;

    if ((m_dwBestPioMode != -1) && (m_dwBestPioMode >= 2)) 
    {
        SetTransferMode( (BYTE)m_dwBestPioMode | ATA_PIO_FCT_MODE);
		//* * * CAMSDB - Added this for setting the mode in CPort class. (START)
		m_pPort->m_ulCurrentMode = (BYTE)m_dwBestPioMode | ATA_PIO_FCT_MODE;
		//* * * CAMSDB - Added this for setting the mode in CPort class. (END)
    }    

    ulMwDmaMode = (int)m_ulBestMwDmaModeReg>(int) m_dwBestMwDmaMode? 
                                        m_dwBestMwDmaMode: 
                                        m_ulBestMwDmaModeReg;

    ulUDmaMode = (int)m_ulBestUDmaModeReg > (int)m_dwBestUDmaMode? 
                                        m_dwBestUDmaMode: 
                                        m_ulBestUDmaModeReg;

    if(m_fDMAActive)
    {
        if (ulUDmaMode != -1 && m_fUDMAActive) 
        {

            m_dwTransferModeCurrent = (UDMA_MODE0 << ulUDmaMode);
            SetTransferMode( (BYTE)ulUDmaMode | ATA_DMA_ULTRA_MODE);
			//* * * CAMSDB - Added this for setting the mode in CPort class. (START)
			m_pPort->m_ulCurrentMode = m_dwTransferModeCurrent;
			//* * * CAMSDB - Added this for setting the mode in CPort class. (END)

            DEBUGMSG
            (
                 ZONE_INIT, 
                (
                    (L"ATAPI:SetBestTransferMode Current mode is UDMA mode = %1x\r\n"),
                    ulUDmaMode
                )
            );
        }
        else if (ulMwDmaMode != -1 ) 
        {
            m_dwTransferModeCurrent = (MWDMA_MODE0 << ulMwDmaMode);
            SetTransferMode( (BYTE)ulMwDmaMode | ATA_DMA_MULTI_WORD_MODE);
			//* * * CAMSDB - Added this for setting the mode in CPort class. (START)
			m_pPort->m_ulCurrentMode = m_dwTransferModeCurrent;
			//* * * CAMSDB - Added this for setting the mode in CPort class. (END)

            DEBUGMSG
            (
                 ZONE_INIT, 
                (
                    (L"ATAPI:SetBestTransferMode Current mode is MDMA mode = %1x\r\n"),
                    ulMwDmaMode
                )
            );
        }
    }
}

//****************************************************************************
// StallExecution
//****************************************************************************
// This eventually need to move into CEDDK class.
// 
//
void StallExecution(ULONG ulMicroSec)
{
    LARGE_INTEGER liStart, liCurrent;
    BOOL b;
    b = QueryPerformanceCounter(&liStart);
    ASSERT(b);
    
    do
    {
        //Sleep(0);
        b = QueryPerformanceCounter(&liCurrent);
        ASSERT(b);
    } while((liStart.QuadPart + (LONGLONG)ulMicroSec) >=liCurrent.QuadPart);
}

//* * * This is very useful.
BOOL CEP931xDisk::TranslateAddress (PDWORD pdwAddr)
{
     return TRUE;
}