ep931xide.cpp

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

    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;
    dwRet = WaitForSingleObject( m_pPort->m_hIdeIntEvent, dwTimeOut);

    //
    // Temporary code.
    //
    if (dwRet == WAIT_TIMEOUT && m_pPort->m_bDMAState) 
    {
        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) 
    {
        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);
    }    

    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);
            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);
            DEBUGMSG
            (
                 ZONE_INIT, 
                (
                    (L"ATAPI:SetBestTransferMode Current mode is MDMA mode = %1x\r\n"),
                    ulMwDmaMode
                )
            );
        }
    }
}
//****************************************************************************
// CEP931XDisk::TestRoutines
//****************************************************************************
// This test PIO and DMA by writing to the fixed sectors on the disk.
// 
//
#define NUM_SG_BUF          3
#define SG_REQ_SIZE         sizeof(SG_REQ) + NUM_SG_BUF * sizeof(SG_BUF)
//#define TEST_SECTOR_NUM     63
#define TEST_SECTOR_NUM     1
//#define TEST_SECTOR_NUM     64
//#define TEST_SECTOR_NUM     2
void CEP931xDisk::TestRoutines(void)
{
    DWORD   dwRetValue;
    IOREQ   IOReq;
    PBYTE   pucBuffer;
    ULONG   ulCount;
    PBYTE pucWriteBuffer,pucReadBuffer;
    ULONG ulTemp;

    PSG_REQ  pSgReq = (PSG_REQ)new unsigned char [SG_REQ_SIZE];
    pucWriteBuffer = (unsigned char*) new ULONG[0x10000];
    pucReadBuffer = (unsigned char*) new ULONG[0x10000];

    IOReq.pInBuf = (PUCHAR)pSgReq;
    IOReq.dwInBufSize =SG_REQ_SIZE;

    #if 0
    for(ulCount = 0; ulCount <5 ; ulCount++)
    {

        pSgReq->sr_num_sec = 1<<ulCount;
        pSgReq->sr_num_sg = 1;
        pSgReq->sr_start  = 1<<ulCount;
        pSgReq->sr_sglist[0].sb_buf    = pucBuffer;
        pSgReq->sr_sglist[0].sb_len    = (1<<ulCount) * BYTES_PER_SECTOR;
    }
    #endif // 0

    NKDbgPrintfW(L"+CEP931xDisk::TestRoutines \r\n");

#if 0
    //
    // Write the data using PIO mode
    //
    pSgReq->sr_num_sec            = 1;
    pSgReq->sr_num_sg             = 1;
    pSgReq->sr_start              = 0;
    pSgReq->sr_sglist[0].sb_buf   = pucWriteBuffer;
    pSgReq->sr_sglist[0].sb_len   = 1 * BYTES_PER_SECTOR;
    
    srand(100);
    for(ulCount = 0; ulCount <(TEST_SECTOR_NUM * BYTES_PER_SECTOR)>>2 ; ulCount++)
    {
        ((PULONG)pucWriteBuffer)[ulCount] = rand();
    }
    dwRetValue = ReadWriteDisk(&IOReq, FALSE);
    ASSERT(dwRetValue == ERROR_SUCCESS);

    //
    // Read the data using PIO mode
    //
    pSgReq->sr_num_sec            = 1;
    pSgReq->sr_num_sg             = 1;
    pSgReq->sr_start              = 0;
    pSgReq->sr_sglist[0].sb_buf   = pucReadBuffer;
    pSgReq->sr_sglist[0].sb_len   = 1 * BYTES_PER_SECTOR;
    dwRetValue = ReadWriteDisk(&IOReq, TRUE);
    ASSERT(dwRetValue == ERROR_SUCCESS);

    srand(100);
    for(ulCount = 0; ulCount <(TEST_SECTOR_NUM * BYTES_PER_SECTOR)>>2 ; ulCount++)
    {
        ulTemp = rand();
        if(PULONG(pucReadBuffer)[ulCount] != ulTemp)
        {
            NKDbgPrintfW(L"  0x%08x != 0x%08x \r\n", ((PULONG)pucReadBuffer)[ulCount], ulTemp);
        }
    }

    //
    // Read the data using DMA mode
    //
    pSgReq->sr_num_sec            = 1;
    pSgReq->sr_num_sg             = 1;
    pSgReq->sr_start              = 0;
    pSgReq->sr_sglist[0].sb_buf   = pucReadBuffer;
    pSgReq->sr_sglist[0].sb_len   = 1 * BYTES_PER_SECTOR;
    dwRetValue = ReadWriteDiskDMA(&IOReq, TRUE);
    ASSERT(dwRetValue == ERROR_SUCCESS);

    srand(100);
    for(ulCount = 0; ulCount <(TEST_SECTOR_NUM * BYTES_PER_SECTOR)>>2 ; ulCount++)
    {
        ulTemp = rand();
        if(PULONG(pucReadBuffer)[ulCount] != ulTemp)
        {
            NKDbgPrintfW(L"  0x%08x != 0x%08x \r\n", ((PULONG)pucReadBuffer)[ulCount], ulTemp);
        }
    }

#endif // 0
    //
    // Write the data using DMA mode
    //
    pSgReq->sr_num_sec            = TEST_SECTOR_NUM;
    pSgReq->sr_num_sg             = 1;
    pSgReq->sr_start              = 0;
    pSgReq->sr_sglist[0].sb_buf   = pucWriteBuffer;
    pSgReq->sr_sglist[0].sb_len   = TEST_SECTOR_NUM * BYTES_PER_SECTOR;
    
    srand(200);
    for(ulCount = 0; ulCount <(TEST_SECTOR_NUM * BYTES_PER_SECTOR)>>2 ; ulCount++)
    {
        ((PULONG)pucWriteBuffer)[ulCount] = rand();
    }
    dwRetValue = ReadWriteDiskDMA(&IOReq, FALSE);
    ASSERT(dwRetValue == ERROR_SUCCESS);


    //
    // Read the data using PIO mode
    //
    pSgReq->sr_num_sec            = TEST_SECTOR_NUM;
    pSgReq->sr_num_sg             = 1;
    pSgReq->sr_start              = 0;
    pSgReq->sr_sglist[0].sb_buf   = pucReadBuffer;
    pSgReq->sr_sglist[0].sb_len   = TEST_SECTOR_NUM * BYTES_PER_SECTOR;
    dwRetValue = ReadWriteDisk(&IOReq, TRUE);
    ASSERT(dwRetValue == ERROR_SUCCESS);

    srand(200);
    for(ulCount = 0; ulCount <(TEST_SECTOR_NUM * BYTES_PER_SECTOR)>>2 ; ulCount++)
    {
        ulTemp = rand();
        if(PULONG(pucReadBuffer)[ulCount] != ulTemp)
        {
            NKDbgPrintfW(L"  0x%08x != 0x%08x \r\n", ((PULONG)pucReadBuffer)[ulCount], ulTemp);
        }
    }

    //
    // Read the data using DMA mode
    //
    pSgReq->sr_num_sec            = TEST_SECTOR_NUM;
    pSgReq->sr_num_sg             = 1;
    pSgReq->sr_start              = 0;
    pSgReq->sr_sglist[0].sb_buf   = pucReadBuffer;
    pSgReq->sr_sglist[0].sb_len   = TEST_SECTOR_NUM * BYTES_PER_SECTOR;
    dwRetValue = ReadWriteDiskDMA(&IOReq, TRUE);
    ASSERT(dwRetValue == ERROR_SUCCESS);

    srand(200);
    for(ulCount = 0; ulCount <(TEST_SECTOR_NUM * BYTES_PER_SECTOR)>>2 ; ulCount++)
    {
        ulTemp = rand();
        if(PULONG(pucReadBuffer)[ulCount] != ulTemp)
        {
            NKDbgPrintfW(L"  0x%08x != 0x%08x \r\n", ((PULONG)pucReadBuffer)[ulCount], ulTemp);
        }
    }

    delete pucWriteBuffer;
    delete pucReadBuffer;

    NKDbgPrintfW(L"-CEP931xDisk::TestRoutines \r\n");

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