//
//  Copyright(C) Renesas Technology Corp. 2005. All rights reserved.
//
// ATAPI(UDFS) driver for ITS-DS7
//
// FILE     : atamain.cpp
// CREATED  : 2005.02.10
// MODIFIED : 2005.04.14
// AUTHOR   : Renesas Technology Corp.
// HARDWARE : RENESAS ITS-DS7
// HISTORY  : 
//            2005.02.10
//            - Created release code.
//                (based on PUBLIC ATAPI driver for WCE5.0)
//            2005.04.14
//            - Modified adjustment of a timing.

//
// 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 <atapishxcd.h>



DWORD CSHXDiskAndCD::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 CSHXDiskAndCD::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 CSHXDiskAndCD::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;
}

DWORD CSHXDiskAndCD::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_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 (IsDMASupported()) {
        dwError = ReadCdRomDMA(CurAddr.Address.lba, pReadInfo->TransferLength, wSectorSize, pReadInfo->sgcount, pSgBuf);
        if (dwError == ERROR_SUCCESS) {
            *(pBytesReturned) = pReadInfo->TransferLength * wSectorSize;
        }
    } else {
        SetupCdRomRead(pReadInfo->bRawMode, CurAddr.Address.lba, pReadInfo->TransferLength, &CmdPkt);
        
        if (AtapiSendCommand(&CmdPkt, wSectorSize, IsDMASupported())) {
            if (!AtapiReceiveData(pSgBuf, pReadInfo->sgcount,pBytesReturned)) {
                dwError = ERROR_READ_FAULT;
            }
        } else {
             dwError = ERROR_READ_FAULT;
        }
    }    
    return dwError;
}

DWORD CSHXDiskAndCD::ReadCdRomDMA(DWORD dwLBAAddr, DWORD dwTransferLength, WORD wSectorSize, DWORD dwSgCount, SGX_BUF *pSgBuf)
{
    ATAPI_COMMAND_PACKET    CmdPkt;
    DWORD                   dwError=ERROR_SUCCESS;
    DWORD               dwSectorsToTransfer;
    SG_BUF              CurBuffer[MAX_SG_BUF];
    WORD                wCount;
    SG_BUF                  SgBufTemp;

    DWORD dwStartBufferNum = 0, dwEndBufferNum = 0, dwEndBufferOffset = 0;
    DWORD dwNumSectors = dwTransferLength;
    DWORD dwStartSector = dwLBAAddr;
	DWORD dwSectorsToTransferMax = ATAPI_BUFFER_SIZE / wSectorSize;

    // Process the SG buffers in blocks of MAX_CD_SECT_PER_COMMAND.  Each DMA request will have a new SG_BUF array 
    // which will be a subset of the original request, and may start/stop in the middle of the original buffer.
    while (dwNumSectors) {
        dwSectorsToTransfer = (dwNumSectors > dwSectorsToTransferMax) ? dwSectorsToTransferMax : dwNumSectors;
    
        DWORD dwBufferLeft = dwSectorsToTransfer * wSectorSize;
        DWORD dwNumSg = 0;

        while (dwBufferLeft) {
            DWORD dwCurBufferLen = pSgBuf[dwEndBufferNum].sb_len - dwEndBufferOffset;

            if (dwBufferLeft < dwCurBufferLen) {
                // The buffer left for this block is less than the current SG buffer length
                CurBuffer[dwEndBufferNum - dwStartBufferNum].sb_buf = pSgBuf[dwEndBufferNum].sb_buf + dwEndBufferOffset;
                CurBuffer[dwEndBufferNum - dwStartBufferNum].sb_len = dwBufferLeft;
                dwEndBufferOffset += dwBufferLeft;
                dwBufferLeft = 0;
            } else {
                // The buffer left for this block is greater than or equal to the current SG buffer length.  Move on to the next SG buffer.
                CurBuffer[dwEndBufferNum - dwStartBufferNum].sb_buf = pSgBuf[dwEndBufferNum].sb_buf + dwEndBufferOffset;
                CurBuffer[dwEndBufferNum - dwStartBufferNum].sb_len = dwCurBufferLen;
                dwEndBufferOffset = 0;
                dwEndBufferNum++;
                dwBufferLeft -= dwCurBufferLen;
            }    
            dwNumSg++;
        }
	    SgBufTemp.sb_len = dwSectorsToTransfer * wSectorSize;
	    SgBufTemp.sb_buf = NULL;

        SetupCdRomRead( wSectorSize == CDROM_RAW_SECTOR_SIZE ? TRUE : FALSE, dwStartSector, dwSectorsToTransfer, &CmdPkt);

        wCount = (SHORT)(SgBufTemp.sb_len >> 1);

        if (AtapiSendCommand(&CmdPkt, wCount, IsDMASupported())) {
			if (!SetupDMA( &SgBufTemp, 1, TRUE)) {
			    dwError = ERROR_READ_FAULT;
			    goto ExitFailure;
			}

	        BeginDMA(TRUE);

            if (m_fInterruptSupported) {
                if (!WaitForInterrupt(m_dwDiskIoTimeOut)) {  
                    DEBUGMSG( ZONE_IO, (TEXT("ATAPI:ReadCdRom- WaitforInterrupt failed (DevId %x) \r\n"),m_dwDeviceId));
                    dwError = ERROR_READ_FAULT;
                    goto ExitFailure;
                }
            }    
            if (EndDMA()) {
                WaitOnBusy(FALSE);
                CompleteDMA( CurBuffer, dwNumSg, TRUE);
            } else {
                dwError = ERROR_READ_FAULT;
                goto ExitFailure;
            }    
        }

        dwStartSector += dwSectorsToTransfer;
        dwStartBufferNum = dwEndBufferNum;
        dwNumSectors -= dwSectorsToTransfer;        
    }    


ExitFailure:
    if (dwError != ERROR_SUCCESS) {
        AbortDMA();
    }    
    return dwError;
}

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
//---------------------------------------------------------------------------
//
//  Send command to ATA Device.
//
//---------------------------------------------------------------------------

BOOL CSHXDiskAndCD::AtapiSendCommand(PATAPI_COMMAND_PACKET pCmdPkt, WORD wCount, BOOL fDMA)
{
    // Set the Drive/Head registers 
    SelectDevice();
    GetBaseStatus();

    SelectDevice();
     if (WaitOnBusy(FALSE))
     {  
         if (GetError() & ATA_STATUS_ERROR)
         {      
            return FALSE;
         }
     }
#if 1
//    for( DWORD dwCount = 0; dwCount < 10; dwCount++)   {
//        if( WaitForInterrupt(0)) {
//            break;
//        }    
//    }
#endif