diskmain.cpp

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

                dwXferMode |= SWDMA_MODE0;
                dwBestXferMode = 0;
            }
            if (m_Id.SingleDmaModesSupported & (1 << 1)) 
            {
                dwCycleTime = SWDMA_MODE1_CYCLE_TIME;
                dwXferMode |= SWDMA_MODE1;
                dwBestXferMode = 1;
            }
            if (m_Id.SingleDmaModesSupported & (1 << 2)) 
            {
                dwCycleTime = SWDMA_MODE2_CYCLE_TIME;
                dwXferMode |= SWDMA_MODE2;
                dwBestXferMode = 2;
            }

            if (m_Id.SingleDmaTransferActive) 
            {

                if (m_Id.SingleDmaTransferActive & IDD_SWDMA_MODE2_ACTIVE) 
                {
                    dwCurrentMode = SWDMA_MODE2;
                } 
                else if (m_Id.SingleDmaTransferActive & IDD_SWDMA_MODE1_ACTIVE) 
                {
                    dwCurrentMode = SWDMA_MODE1;
                }  
                else if (m_Id.SingleDmaTransferActive & IDD_SWDMA_MODE0_ACTIVE) 
                {
                    dwCurrentMode = SWDMA_MODE0;
                }
            }
        }
*/
        m_dwBestSwDmaCycleTime    = dwCycleTime;
        m_dwBestSwDmaMode         = dwBestXferMode;

        //
        // check multiword DMA timing
        //
        dwCycleTime = UNINITIALIZED_CYCLE_TIME;
        dwBestXferMode = UNINITIALIZED_TRANSFER_MODE;

		// EP931x rev E1 doesn't support multi-word DMA so don't check it.
		/*
        if (m_Id.MultiDmaModesSupported) 
        {
            DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilitiestarget %d IdentifyData MultiWordDMASupport = 0x%x\r\n"),                             
                         m_dwDevice,
                         m_Id.MultiDmaModesSupported));
            DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilitiestarget %d IdentifyData MultiWordDMAActive = 0x%x\r\n"),                
                         m_dwDevice,
                         m_Id.SingleDmaTransferActive));

            if (m_Id.MultiDmaModesSupported & (1 << 0)) 
            {
                dwCycleTime = MWDMA_MODE0_CYCLE_TIME;
                dwXferMode |= MWDMA_MODE0;
                dwBestXferMode = 0;
            }

            if (m_Id.MultiDmaModesSupported & (1 << 1)) 
            {
                dwCycleTime = MWDMA_MODE1_CYCLE_TIME;
                dwXferMode |= MWDMA_MODE1;
                dwBestXferMode = 1;
            }

            if (m_Id.MultiDmaModesSupported & (1 << 2)) 
            {
                dwCycleTime = MWDMA_MODE2_CYCLE_TIME;
                dwXferMode |= MWDMA_MODE2;
                dwBestXferMode = 2;
            }

            if (m_Id.MultiDmaTransferActive) 
            {
                if (m_Id.MultiDmaTransferActive & IDD_MWDMA_MODE2_ACTIVE) 
                {
                    dwCurrentMode = MWDMA_MODE2;
                } 
                else if (m_Id.MultiDmaTransferActive & IDD_MWDMA_MODE1_ACTIVE) 
                {
                    dwCurrentMode = MWDMA_MODE1;
                }  
                else if (m_Id.MultiDmaTransferActive & IDD_MWDMA_MODE0_ACTIVE) 
                {
                    dwCurrentMode = MWDMA_MODE0;
                }
            }
        }
		

        if (m_Id.TranslationFieldsValid & (1 << 1)) 
        {

            DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilitiestarget %d IdentifyData word 64-70 are valid\r\n"), m_dwDevice));

            if (m_Id.MinimumMultiwordDMATime &&  m_Id.ManuRecomendedDMATime) 
            {
                DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilitiestarget %d IdentifyData MinimumPIOxferTimeWOFlow = 0x%x\r\n"),                                 
                             m_dwDevice,
                             m_Id.MinimumPIOxferTimeWOFlow));
                DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilitiestarget %d IdentifyData ManuRecomendedDMATime = 0x%x\r\n"),
                             m_dwDevice,
                             m_Id.ManuRecomendedDMATime));
                dwCycleTime = m_Id.MinimumPIOxferTimeIORDYFlow;
            }
        }

 */
		m_dwBestMwDmaCycleTime = dwCycleTime;
        m_dwBestMwDmaMode      = dwBestXferMode;

        //
        // figure out the ultra DMA timing the device supports
        //
        dwCycleTime = UNINITIALIZED_CYCLE_TIME;
        dwBestXferMode = UNINITIALIZED_TRANSFER_MODE;

        if (m_Id.TranslationFieldsValid & (1 << 2)) 
        {
            if (m_Id.UltraDMASupport) 
            {
                DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilitiestarget %d IdentifyData UltraDMASupport = 0x%x\r\n"),                                 
                             m_dwDevice,
                             m_Id.UltraDMASupport));
                DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilitiestarget %d IdentifyData UltraDMAActive = 0x%x\r\n"),                                 
                             m_dwDevice,
                             m_Id.UltraDMAActive));
                if (m_Id.UltraDMASupport & (1 << 0)) 
                {
                    dwCycleTime = UDMA_MODE0_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE0;
                    dwBestXferMode = 0;
                }
                if (m_Id.UltraDMASupport & (1 << 1)) 
                {
                    dwCycleTime = UDMA_MODE1_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE1;
                    dwBestXferMode = 1;
                }
                if (m_Id.UltraDMASupport & (1 << 2)) 
                {
                    dwCycleTime = UDMA_MODE2_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE2;
                    dwBestXferMode = 2;
                }
				// Even the IDE device can support higher UDMA mode than 3,
				// EP931x Rev E1 doesn't support UDMA4 or up.
				// so set UDMA mode to 3.
                //if (m_Id.UltraDMASupport & (1 << 3)) 
                if (m_Id.UltraDMASupport & 0xf8 ) 
                {
                    dwCycleTime = UDMA_MODE3_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE3;
                    dwBestXferMode = 3;
                }
               /* if (m_Id.UltraDMASupport & (1 << 4)) 
                {
                    dwCycleTime = UDMA_MODE4_CYCLE_TIME;
                    dwXferMode |= UDMA_MODE4;
                    dwBestXferMode = 4;
                } */
            }

            if (m_Id.UltraDMAActive) 
            {
               /* if (m_Id.UltraDMAActive & IDD_UDMA_MODE4_ACTIVE) 
                {
                    dwCurrentMode = UDMA_MODE4;
                } 
                else if (m_Id.UltraDMAActive & IDD_UDMA_MODE3_ACTIVE) 
				*/
				// Set UDMA mode up to 3.
				if (m_Id.UltraDMAActive & 0xf8) 
                {
                    dwCurrentMode = UDMA_MODE3;
                } 
                else if (m_Id.UltraDMAActive & IDD_UDMA_MODE2_ACTIVE) 
                {
                    dwCurrentMode = UDMA_MODE2;
                } 
                else if (m_Id.UltraDMAActive & IDD_UDMA_MODE1_ACTIVE) 
                {
                    dwCurrentMode = UDMA_MODE1;
                }  
                else if (m_Id.UltraDMAActive & IDD_UDMA_MODE0_ACTIVE) 
                {
                    dwCurrentMode = UDMA_MODE0;
                }
            }
        }

        //
        // Doesn't really know the ultra dma cycle time
        //
        m_dwBestUDmaCycleTime = dwCycleTime;
        m_dwBestUDmaMode      = dwBestXferMode;

        m_dwTransferModeSupported = dwXferMode;
        m_dwTransferModeCurrent  |= dwCurrentMode;


        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities target %d transfer timing:\r\n"),m_dwDevice));

        //* * * CAMSDB03/30/04 - Added a '0x' for mode display in all the DEBUGMSG's below.

        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities PIO mode supported = 0x%04x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & PIO_SUPPORT,
                        m_dwBestPioCycleTime));
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities SWDMA mode supported = 0x%04x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & SWDMA_SUPPORT,
                        m_dwBestSwDmaCycleTime));
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities MWDMA mode supported = 0x%04x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & MWDMA_SUPPORT,
                        m_dwBestSwDmaCycleTime));
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities UDMA mode supported = 0x%04x and best cycle time = %5d ns\r\n"),
                        m_dwTransferModeSupported & UDMA_SUPPORT,
                        m_dwBestUDmaCycleTime));
        
        //* * * CAMSDB03/30/04 - Uncommented the line below (START)
        DEBUGMSG( ZONE_INIT, (TEXT("ATAPI:AnalyzeDeviceCapabilities Current mode bitmap  = %04x\r\n"),
                        m_dwTransferModeCurrent));
        //* * * CAMSDB03/30/04 - Uncommented the line below (END)

    }
} // AnalyzeDeviceCapabilities


// ----------------------------------------------------------------------------
// Function: ValidateSg
//     Map embedded pointers
//
// Parameters:
//     pSgReq -
//     InBufLen - The size of the actual buffer as specified by the user.
//                This needs to be cross checked with pSgReq->sr_num_sg to
//                prevent buffer overflows
//     saveoldptrs - Your old pointers are saved here. Must be at least
//                   pSgReq->sr_num_sg in size
// ----------------------------------------------------------------------------
BOOL CDisk::ValidateSg(
  PSG_REQ pSgReq, DWORD InBufLen, DWORD dwArgType, OUT PUCHAR * saveoldptrs)
{
    DWORD dwIndex ;
    PUCHAR ptemp;

    if (NULL == pSgReq) {
        ASSERT(pSgReq);
        return FALSE;
    }

    if (InBufLen < sizeof(SG_REQ)) {
        ASSERT(InBufLen >= sizeof(SG_REQ));
        return FALSE;
    }

    // pSgReq is a sterile copy of the caller's SG_REQ; we're supposed to map
    // the embedded sb_bufs back into the SG_REQ

    if(
        !(pSgReq->sr_num_sg >= 1) ||
        !(pSgReq->sr_num_sg <= MAX_SG_BUF) ||
        !((sizeof(SG_REQ) + sizeof(SG_BUF)*(pSgReq->sr_num_sg-1)) == InBufLen) ||
        !(pSgReq->sr_num_sec > 0))
    {
        ASSERT(pSgReq->sr_num_sg >= 1);
        ASSERT(pSgReq->sr_num_sg <= MAX_SG_BUF);
        ASSERT((sizeof(SG_REQ) + sizeof(SG_BUF)*(pSgReq->sr_num_sg-1)) == InBufLen);
        ASSERT(pSgReq->sr_num_sec > 0);
        return FALSE;
    }

    for (dwIndex = 0; dwIndex < pSgReq->sr_num_sg; dwIndex++) {
        if (
            (NULL == pSgReq->sr_sglist[dwIndex].sb_buf) ||
            (0 == pSgReq->sr_sglist[dwIndex].sb_len)
        ) {
            goto CleanUpLeak;
        }

        // Verify embedded pointer access and map user mode pointers
        if (FAILED(CeOpenCallerBuffer(
                    (PVOID *)&ptemp,
                    (LPVOID)pSgReq->sr_sglist[dwIndex].sb_buf,
                    pSgReq->sr_sglist[dwIndex].sb_len,
                    dwArgType,
                    FALSE)))
        {
            goto CleanUpLeak;
        }

        saveoldptrs[dwIndex] = pSgReq->sr_sglist[dwIndex].sb_buf;
        pSgReq->sr_sglist[dwIndex].sb_buf = ptemp;

        if (NULL == pSgReq->sr_sglist[dwIndex].sb_buf) {
            goto CleanUpLeak;
        }

    }

    return TRUE;

CleanUpLeak:

    if (FAILED(UnmapSg(
                pSgReq->sr_sglist,
                saveoldptrs,
                dwIndex,
                dwArgType)))
    {
        ASSERT(!"Cleanup call to CeCloseCallerBuffer failed unexpectedly");
        return FALSE;
    }

    return FALSE;

}


BOOL CDisk::ValidateSg(PCDROM_READ pCdrom ,DWORD InBufLen)
{
    if (PSLGetCallerTrust()!= OEM_CERTIFY_TRUST) {
        if  (pCdrom && InBufLen >= (sizeof(CDROM_READ) + sizeof(SGX_BUF) * (pCdrom->sgcount - 1))) {
            DWORD dwIndex;
            for (dwIndex=0; dwIndex < pCdrom-> sgcount; dwIndex++) {
                pCdrom->sglist[dwIndex].sb_buf = pCdrom->sglist[dwIndex].sb_buf;
                    //(PUCHAR)MapCallerPtr((LPVOID)pCdrom->sglist[dwIndex].sb_buf,pCdrom->sglist[dwIndex].sb_len);
            }
        }
        else // Parameter Wrong.
            return FALSE;
    }
    return TRUE;
}

// ----------------------------------------------------------------------------
// Function: UnmapSg
//     UnMap embedded pointers, previously mapped by ValidateSg.
//     Basically, an SG Array version of CeCloseCallerBuffer
//
// Parameters:
//     sr_sglist - List of mapped SG buffers to unmap
//     saveoldptrs - List of old unmapped pointers
//     sr_sglistlen - The size of sr_sglist
//     dwArgType - ARG_O_PTR/ ARG_I_PTR
//     Return value -  HRESULT from a failed call to CeCloseCallerBuffer
//                     otherwise ERROR_SUCCESS
// ----------------------------------------------------------------------------
HRESULT
CDisk::UnmapSg(
    IN const SG_BUF * sr_sglist,
    IN const PUCHAR * saveoldptrs,
    IN DWORD sr_sglistlen,
    IN DWORD dwArgType
    )
{
    HRESULT dwError = ERROR_SUCCESS;    
    ASSERT(sr_sglistlen <= MAX_SG_BUF);
    
    for (DWORD dwIndex = 0; dwIndex < sr_sglistlen; dwIndex++) {

        HRESULT dwtemp;
        ASSERT(NULL != sr_sglist[dwIndex].sb_buf);
        ASSERT(0 != sr_sglist[dwIndex].sb_len);

        // Close pointers previously mapped in ValidateSg

        dwtemp = CeCloseCallerBuffer(
                    (LPVOID)sr_sglist[dwIndex].sb_buf,
                    (LPVOID)saveoldptrs[dwIndex],
                    sr_sglist[dwIndex].sb_len,
                    dwArgType);
        
        if (FAILED(dwtemp)) {
            ASSERT(!"Cleanup call to CeCloseCallerBuffer failed unexpectedly");