cdio.cpp

Ep93XX TionProV2 BSP

//**********************************************************************
//                                                                      
// Filename: cdio.cpp
//                                                                      
// Description: 
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Use of this source code is subject to the terms of the Cirrus end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to 
// use this source code. For a copy of the EULA, please see the 
// EULA.RTF on your install media.
//
// Copyright(c) Cirrus Logic Corporation 2005, All Rights Reserved
//                                                                      
//**********************************************************************
//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//**********************************************************************


#include <atamain.h>
#include <CEDDK.h>
#include <oalintr.h>
#include <hwdefs.h>
#include <dbgapi.h>

DWORD CDisk::AtapiIoctl(PIOREQ pIOReq)
{
    DWORD dwError = ERROR_SUCCESS;
    BOOL fIsDVD = FALSE;
    DEBUGMSG( ZONE_IOCTL, (TEXT("ATAPI:PerformIoctl: %x DeviceId: %x \r\n"),pIOReq->dwCode, m_dwDeviceId));

    switch( pIOReq->dwCode) 
    {
        ///////////////////// ATAPI  /////////////////////////////////////                
        case IOCTL_CDROM_READ_SG:
            // Verify that the buffer is of valid size
            {
                if (!AtapiIsUnitReadyEx()) 
                    return ERROR_NOT_READY;
                if ((pIOReq->pInBuf == NULL) || (pIOReq->pBytesReturned == NULL) ||
                   !ValidateSg((CDROM_READ *)pIOReq->pInBuf,pIOReq->dwInBufSize)) 
                {
                    dwError = ERROR_INVALID_PARAMETER;
                } 
                else 
                {
                    dwError = ReadCdRom((CDROM_READ *)pIOReq->pInBuf, pIOReq->pBytesReturned);
                }    
            }    
            break;
        case IOCTL_CDROM_RAW_READ:
            {
                if (!AtapiIsUnitReadyEx()) 
                    return ERROR_NOT_READY;
                RAW_READ_INFO *prri = (RAW_READ_INFO *)pIOReq->pInBuf;
                if (prri && (pIOReq->dwInBufSize == sizeof(RAW_READ_INFO)) && pIOReq->pOutBuf) 
                {
                    CDROM_READ cdr;
                    cdr.StartAddr.Mode = CDROM_ADDR_LBA;
                    cdr.bRawMode = TRUE;
                    cdr.sgcount = 1;
                    cdr.TrackMode = CDDA;
                    cdr.StartAddr.Address.lba = prri->DiskOffset.LowPart;
                    cdr.TransferLength = (DWORD)(prri->SectorCount & 0xffffffff);
                    cdr.sglist[0].sb_buf = pIOReq->pOutBuf;
                    cdr.sglist[0].sb_len = pIOReq->dwOutBufSize;
                    dwError = ReadCdRom(&cdr, pIOReq->pBytesReturned);
                } 
                else 
                {
                    dwError = ERROR_INVALID_PARAMETER;
                }    
            }    
            break;
        case IOCTL_CDROM_TEST_UNIT_READY:
            if (!AtapiIsUnitReady(pIOReq)) {
                dwError = ERROR_NOT_READY;
            }
            break;   
        case IOCTL_CDROM_DISC_INFO:
            if (!AtapiIsUnitReadyEx()) return ERROR_NOT_READY;
            dwError = AtapiGetDiscInfo(pIOReq);
            break;    
        case IOCTL_CDROM_EJECT_MEDIA:
            dwError = AtapiLoadMedia(TRUE);
            break;
        case IOCTL_CDROM_LOAD_MEDIA:
            dwError = AtapiLoadMedia(FALSE);
            break;
        case IOCTL_CDROM_GET_SENSE_DATA:
            {
                CD_SENSE_DATA *pSenseData = (CD_SENSE_DATA *)pIOReq->pOutBuf;
                if ((pSenseData == NULL) || 
                    (pIOReq->dwOutBufSize < sizeof(CD_SENSE_DATA))) {
                    dwError = ERROR_INVALID_PARAMETER;
                } else {
                    dwError = AtapiGetSenseInfo(pSenseData)? ERROR_SUCCESS : ERROR_GEN_FAILURE;
                }    
            }    
            break;
        case IOCTL_CDROM_ISSUE_INQUIRY:
            {
                INQUIRY_DATA *pInquiryData = (INQUIRY_DATA *)pIOReq->pOutBuf;
                if ((pInquiryData == NULL) || 
                    (pIOReq->dwOutBufSize< sizeof(INQUIRY_DATA))) {
                    dwError = ERROR_INVALID_PARAMETER;
                } else {
                    dwError = AtapiIssueInquiry(pInquiryData)? ERROR_SUCCESS : ERROR_GEN_FAILURE;
                }  
            }
            break;
        case IOCTL_CDROM_READ_TOC:
            {
                if (!AtapiIsUnitReadyEx()) return ERROR_NOT_READY;
                CDROM_TOC *pTOC = NULL;
                if (pIOReq->pInBuf && (pIOReq->dwInBufSize == sizeof(CDROM_TOC))) {
                    pTOC = (CDROM_TOC *)pIOReq->pInBuf;
                } else 
                if (pIOReq->pOutBuf && (pIOReq->dwOutBufSize == sizeof(CDROM_TOC))) {
                    pTOC = (CDROM_TOC *)pIOReq->pOutBuf;
                }    
                if (pTOC == NULL) {
                    dwError = ERROR_INVALID_PARAMETER;
                } else {
                    dwError = AtapiGetToc(pTOC) ? ERROR_SUCCESS : ERROR_GEN_FAILURE;
                }  
            }
            break;                
///////////////////// DVD ///////////////////////////////////////                
        case IOCTL_DVD_START_SESSION:
        case IOCTL_DVD_READ_KEY:
            if (!AtapiIsUnitReadyEx()) return ERROR_NOT_READY;
            dwError = DVDReadKey(pIOReq);
            break;
        case IOCTL_DVD_END_SESSION:
        case IOCTL_DVD_SEND_KEY:
            if (!AtapiIsUnitReadyEx()) return ERROR_NOT_READY;
            dwError = DVDSendKey(pIOReq);
            break;
        case IOCTL_DVD_GET_REGION:
            dwError = DVDGetRegion(pIOReq);
            break;
        case IOCTL_DVD_SET_REGION:
            dwError = DVDSetRegion(pIOReq);
            break;    
///////////////////// CDAUDIO ///////////////////////////////////                
        case IOCTL_CDROM_READ_Q_CHANNEL:
            if (!AtapiIsUnitReadyEx()) return ERROR_NOT_READY;
            dwError = AtapiReadQChannel(pIOReq);
            break;
        case IOCTL_CDROM_PLAY_AUDIO_MSF:
        case IOCTL_CDROM_SEEK_AUDIO_MSF:
        case IOCTL_CDROM_RESUME_AUDIO:
        case IOCTL_CDROM_STOP_AUDIO:
        case IOCTL_CDROM_PAUSE_AUDIO:
        case IOCTL_CDROM_SCAN_AUDIO:
            if (!AtapiIsUnitReadyEx()) return ERROR_NOT_READY;
            dwError = ControlAudio(pIOReq);
            break;
        default:
            dwError = ERROR_NOT_SUPPORTED;
            break;
    }        
    return dwError;
}


BOOL CDisk::AtapiIsUnitReadyEx()
{
    DWORD dwCount;
    for (dwCount = 0; dwCount < 5; dwCount++) {
        if (AtapiIsUnitReady()) {
            m_dwLastCheckTime = GetTickCount();
            break;
        }    
        StallExecution(100);
    }
    if (dwCount == 5)
        return FALSE;
    return TRUE;
}

DWORD CDisk::SetupCdRomRead(BOOL bRawMode, DWORD dwLBAAddr, DWORD dwTransferLength, PATAPI_COMMAND_PACKET pCmdPkt)
{
    BOOL fIsDVD = (m_dwDeviceFlags & DFLAGS_DEVICE_ISDVD);  

    memset( pCmdPkt, 0, sizeof(ATAPI_COMMAND_PACKET));


    /**** Atapi Packet *****
    Byte 0 - Cmd/OpCode
    Byte 1 - N/A
    Byte 2 - Logical Block (MSB)
    Byte 2 - Logical Block 
    Byte 2 - Logical Block 
    Byte 2 - Logical Block (LSB)
    Byte 6 - Reserved
    Byte 7 - DataLength (MSB)
    Byte 8 - DataLength (LSB)
    Byte 9 - Control Byte
    ****** Atapi Packet ****/
    pCmdPkt->Byte_1 = 0x00;
    pCmdPkt->Byte_2 = LBA_MSB(&dwLBAAddr);
    pCmdPkt->Byte_3 = LBA_3rdLSB(&dwLBAAddr);
    pCmdPkt->Byte_4 = LBA_2ndLSB(&dwLBAAddr);
    pCmdPkt->Byte_5 = LBA_LSB(&dwLBAAddr);
    if (fIsDVD && !bRawMode) 
    {
        pCmdPkt->Opcode = ATAPI_PACKET_CMD_READ_12;
        pCmdPkt->Byte_6 = (BYTE)( dwTransferLength >> 24);
        pCmdPkt->Byte_7 = (BYTE)( (dwTransferLength & 0x00ff0000) >> 16);
        pCmdPkt->Byte_8 = (BYTE)( (dwTransferLength & 0x0000ff00) >> 8);
        pCmdPkt->Byte_9 = (BYTE)( dwTransferLength);
    } 
    else 
    {
        pCmdPkt->Opcode = bRawMode ? ATAPI_PACKET_CMD_READ_CD : ATAPI_PACKET_CMD_READ;
        pCmdPkt->Byte_6 = 0x00; // Reserved
        pCmdPkt->Byte_7 = (BYTE)( (dwTransferLength & 0x0000ff00) >> 8);
        pCmdPkt->Byte_8 = (BYTE)( dwTransferLength);
        pCmdPkt->Byte_9 = 0x10;
    }

    pCmdPkt->Byte_10 = 0;          
    return ERROR_SUCCESS;
}
//****************************************************************************
// CDisk::ReadCdRom
//****************************************************************************
// 
// 
//

DWORD CDisk::ReadCdRom(CDROM_READ *pReadInfo, PDWORD pBytesReturned)
{
//    ATAPI_COMMAND_PACKET    CmdPkt;
    CDROM_ADDR              CurAddr;
    WORD                    wSectorSize;
    DWORD                   dwError=ERROR_SUCCESS;
    PSGX_BUF                pSgBuf;
    
    GetBaseStatus(); // Clear Interrupt if it is already set 
    
    CurAddr = pReadInfo->StartAddr;

    // The request must either be in MSF format or LBA format
    DEBUGCHK(pReadInfo->StartAddr.Mode == CDROM_ADDR_MSF || pReadInfo->StartAddr.Mode == CDROM_ADDR_LBA);
    
    DEBUGMSG
    ( 
        ZONE_DMA | ZONE_IO | ZONE_CDROM, 
        (
            TEXT("ATAPI:ReadCdRom Address=%ld Mode=%02X Length=%ld TrackMode=%02X\r\n"), 
            CurAddr.Address, 
            CurAddr.Mode, 
            pReadInfo->TransferLength, 
            pReadInfo->TrackMode
        )
    );

    //
    // If in MSF format then convert it to LBA
    //
    if (CurAddr.Mode == CDROM_ADDR_MSF) 
    {
        CDROM_MSF_TO_LBA(&CurAddr);
    }    

    //
    // Verify that the transfer count is not 0
    //
    if ((pReadInfo->TransferLength == 0) || (pReadInfo->sgcount == 0)) 
    {
       return ERROR_INVALID_PARAMETER;
    }

    if( pReadInfo->bRawMode) 
    {
        wSectorSize = CDROM_RAW_SECTOR_SIZE;
    } 
    else 
    {
        wSectorSize = CDROM_SECTOR_SIZE;
    }

    pSgBuf = &(pReadInfo->sglist[0]);

    if (IsReadDMASupported()) 
    {
        dwError = ReadCdRomDMA
        (
            pReadInfo->bRawMode,
            CurAddr.Address.lba, 
            pReadInfo->TransferLength, 
            pReadInfo->sgcount, 
            pSgBuf,
            pBytesReturned
        );
    } 
    else 
    {
        dwError = ReadCdRomPIO
        (
            pReadInfo->bRawMode,
            CurAddr.Address.lba, 
            pReadInfo->TransferLength, 
            pReadInfo->sgcount, 
            pSgBuf,
            pBytesReturned
        );
    }    
    return dwError; 
}
//****************************************************************************
// CDisk::ReadCdRomDMA
//****************************************************************************
// Performs a CDROM UDMA read.
// 
//

DWORD CDisk::ReadCdRomDMA
(
    BOOL    bRawMode,
    DWORD   dwLBAAddr, 
    DWORD   dwTransferLength, 
    DWORD   dwSgCount, 
    SGX_BUF *pSgBuf,
    DWORD   *pBytesRead
)
{
    ATAPI_COMMAND_PACKET    CmdPkt; 
    DWORD                   dwError=ERROR_SUCCESS;
    DWORD               dwSectorsToTransfer;
    SG_BUF              CurBuffer[MAX_SG_BUF];
    WORD                wCount;
    DWORD               dwStartBufferNum = 0, dwEndBufferNum = 0, dwEndBufferOffset = 0;
    DWORD               dwNumSectors = dwTransferLength;
    DWORD               dwStartSector = dwLBAAddr;
    WORD                wSectorSize;
    ULONG               ulWaitReturn;
    ULONG               ulNumRetries;
    BOOL                bRetryUsingPIO = FALSE;

    DEBUGMSG( ZONE_CDROM, (TEXT("+CDisk::ReadCdRomDMA\r\n")));


    if( bRawMode) 
    {