atapiromi.cpp

Samsung公司S3C6400芯片的BSP源码包

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

/*++

Module Name:
    atapiRomi.cpp
        based on atapipci.cpp

Abstract:
    ATA/ATAPI for 2440 Ref Board.

Revision History:

--*/

#include "atapiRomi.h"
#include "atapiRomipm.h"
#include "bsp_cfg.h"

#define RTL_MSG 1
#define DirectMode 1
#define IndirectMode 0

LONG CRomiDisk::m_lDeviceCount = 0;

static TCHAR *g_szPCICDRomDisk = TEXT("CD-ROM");
static TCHAR *g_szPCIHardDisk = TEXT("Hard Disk");

// ----------------------------------------------------------------------------
// Function: CreatePCIHD
//     Spawn function called by IDE/ATA controller enumerator
//
// Parameters:
//     hDevKey -
// ----------------------------------------------------------------------------


EXTERN_C
CDisk *
CreateRomi(
    HKEY hDevKey
    )
{
    return new CRomiDisk(hDevKey);
}

// ----------------------------------------------------------------------------
// Function: CRomiDisk
//     Constructor
//
// Parameters:
//     hKey -
// ----------------------------------------------------------------------------

CRomiDisk::CRomiDisk(
    HKEY hKey
    ) : CDisk(hKey)
{
    m_pStartMemory = NULL;
    m_pPort = NULL;
    m_pPhysList = NULL;
    m_pSGCopy = NULL;
    m_pPFNs = NULL;
    m_pPRDPhys = 0;
    m_pPRD = NULL;
    m_dwPhysCount = 0;
    m_dwSGCount = 0;
    m_dwPRDSize = 0;
    m_pBMCommand = NULL;

    InterlockedIncrement(&m_lDeviceCount);

    DEBUGMSG(ZONE_INIT|ZONE_PCI, (_T(
        "Atapi!CRomiDisk::CRomiDisk> device count(%d)\r\n"
        ), m_lDeviceCount));
}

// ----------------------------------------------------------------------------
// Function: ~CRomiDisk
//     Destructor
//
// Parameters:
//     None
// ----------------------------------------------------------------------------

CRomiDisk::~CRomiDisk(
    )
{
    FreeDMABuffers();

	if ( m_vpSYSCONRegs)
	{
		DrvLib_UnmapIoSpace((PVOID)m_vpSYSCONRegs);
		m_vpSYSCONRegs= NULL;
	}

	if ( m_vpIOPORTRegs)
	{
		DrvLib_UnmapIoSpace((PVOID)m_vpIOPORTRegs);
		m_vpIOPORTRegs= NULL;
	}

	if ( m_pDMAVirtualAddress )
	{
		PHYSICAL_ADDRESS PhysicalAddress;

		PhysicalAddress.LowPart = m_DMAPhyaddress.LowPart;
		HalFreeCommonBuffer(0, 0, PhysicalAddress, (PVOID)m_pDMAVirtualAddress, FALSE);
		m_pDMAVirtualAddress = NULL;
	}

	InterlockedDecrement(&m_lDeviceCount);

    DEBUGMSG(ZONE_INIT|ZONE_PCI, (_T(
        "Atapi!CRomiDisk::~CRomiDisk> device count(%d)\r\n"
        ), m_lDeviceCount));
}

// ----------------------------------------------------------------------------
// Function: FreeDMABuffers
//     Deallocate DMA buffers
//
// Parameters:
//     None
// ----------------------------------------------------------------------------

void
CRomiDisk::FreeDMABuffers(
    )
{
    if (m_pPRD) {
        FreePhysMem(m_pPRD);
        m_pPRDPhys = NULL;
        m_pPRD = NULL;
    }

    if (m_pPhysList) {
        // free the fixed pages; the variable pages should already be free
        for (DWORD i = 0; i < MIN_PHYS_PAGES; i++) {
            FreePhysMem(m_pPhysList[i].pVirtualAddress);
        }
        VirtualFree(m_pPhysList, UserKInfo[KINX_PAGESIZE], MEM_DECOMMIT);
        m_pPhysList = NULL;
    }

    if (m_pSGCopy) {
        VirtualFree(m_pSGCopy, UserKInfo[KINX_PAGESIZE], MEM_DECOMMIT);
        m_pSGCopy = NULL;
    }

    if (m_pPFNs) {
        VirtualFree(m_pPFNs, UserKInfo[KINX_PAGESIZE], MEM_DECOMMIT);
        m_pSGCopy = NULL;
    }

    VirtualFree(m_pStartMemory, 0, MEM_RELEASE);
    m_pStartMemory = NULL;

    m_dwPhysCount = 0;
    m_dwSGCount = 0;
}

// ----------------------------------------------------------------------------
// Function: CopyDiskInfoFromPort
//     This function is not used
//
// Parameters:
//     None
// ----------------------------------------------------------------------------

void
CRomiDisk::CopyDiskInfoFromPort(
    )
{
    ASSERT(m_pPort->m_dwRegBase != 0);
    m_pATAReg = (PBYTE)m_pPort->m_dwRegBase;
    m_pATARegAlt = (PBYTE)m_pPort->m_dwRegAlt;

    ASSERT(m_pPort->m_dwBMR != 0);
    m_pBMCommand = (LPBYTE)m_pPort->m_dwBMR;
}

// ----------------------------------------------------------------------------
// Function: WaitForInterrupt
//     Wait for interrupt
//
// Parameters:
//     dwTimeOut -
// ----------------------------------------------------------------------------

BOOL
CRomiDisk::WaitForInterrupt(
    DWORD dwTimeOut
    )
{
    BYTE bStatus;
    BOOL fRet = TRUE;
    DWORD dwRet;

    // wait for interrupt
    dwRet = WaitForSingleObject(m_pPort->m_hIRQEvent, dwTimeOut);
    if (dwRet == WAIT_TIMEOUT) {
        fRet = FALSE;
    }
    else {
        if (dwRet != WAIT_OBJECT_0) {
            if (!WaitForDisc(WAIT_TYPE_DRQ, dwTimeOut, 10)) {
                fRet = FALSE;
            }
        }
    }

    // read status; acknowledge interrupt
    bStatus = GetBaseStatus();
    if (bStatus & ATA_STATUS_ERROR) {
        bStatus = GetError();
        fRet = FALSE;
    }

    // signal interrupt done
    InterruptDone(m_pPort->m_dwSysIntr);

    return fRet;
}

// ----------------------------------------------------------------------------
// Function: EnableInterrupt
//     Enable channel interrupt
//
// Parameters:
//     None
// ----------------------------------------------------------------------------

void
CRomiDisk::EnableInterrupt(
    )
{
    GetBaseStatus(); // acknowledge interrupt, if pending

    // signal interrupt done
    InterruptDone(m_pPort->m_dwSysIntr);
}

// ----------------------------------------------------------------------------
// Function: ConfigureRegisterBlock
//     This function is called by DSK_Init before any other CDisk function to
//     set up the register block.
//
// Parameters:
//     dwStride -
// ----------------------------------------------------------------------------

VOID
CRomiDisk::ConfigureRegisterBlock(
    DWORD dwStride
    )
{

    m_dwStride = dwStride;
    m_dwDataDrvCtrlOffset = ATA_PIO_DTR;//ATA_REG_DATA * dwStride;
    m_dwFeatureErrorOffset = ATA_PIO_FED;//ATA_REG_FEATURE * dwStride;
    m_dwSectCntReasonOffset = ATA_PIO_SCR;//ATA_REG_SECT_CNT * dwStride;
    m_dwSectNumOffset = ATA_PIO_LLR;//ATA_REG_SECT_NUM * dwStride;
    m_dwByteCountLowOffset = ATA_PIO_LMR;//ATA_REG_BYTECOUNTLOW * dwStride;
    m_dwByteCountHighOffset = ATA_PIO_LHR;//ATA_REG_BYTECOUNTHIGH * dwStride;
    m_dwDrvHeadOffset = ATA_PIO_DVR;//ATA_REG_DRV_HEAD * dwStride;
    m_dwCommandStatusOffset =ATA_PIO_CSD;// ATA_REG_COMMAND * dwStride;

    // PCI ATA implementations don't assign I/O resources for the first four
    // bytes, as they are unused

    m_dwAltStatusOffset = ATA_PIO_DAD;//8 * dwStride;//ATA_REG_ALT_STATUS * dwStride;
    m_dwAltDrvCtrl = ATA_PIO_DAD;//8 * dwStride;//ATA_REG_DRV_CTRL * dwStride;
}

// ----------------------------------------------------------------------------
// Function: Init
//     Initialize channel
//
// Parameters:
//     hActiveKey -
// ----------------------------------------------------------------------------

BOOL
CRomiDisk::Init(
    HKEY hActiveKey
    )
{
    BOOL bRet = FALSE;

    m_f16Bit = TRUE; // PCI is 16-bit


    // configure port
    if (!ConfigPort()) {
        DEBUGMSG(ZONE_INIT, (_T(
            "Atapi!CRomiDisk::Init> Failed to configure port; device(%u)\r\n"
            ), m_dwDeviceId));
        RETAILMSG(1, (_T(
            "Atapi!CRomiDisk::Init> Failed to configure port; device(%u)\r\n"
            ), m_dwDeviceId));

        goto exit;
    }

    // assign the appropriate folder name
    //m_szDiskName = (IsCDRomDevice() ? g_szPCICDRomDisk : g_szPCIHardDisk);

    // reserve memory for DMA buffers
    m_pStartMemory = (LPBYTE)VirtualAlloc(NULL, 0x10000, MEM_RESERVE, PAGE_READWRITE);
    if (!m_pStartMemory) {
        bRet = FALSE;
    }

	*(UINT32 *)(m_pATAReg + ATA_CONTROL) |= 1;
	//*(UINT32 *)(m_pATAReg + ATA_CFG ) |= 0x40; // set big endian hsjang
    // finish intialization; i.e., initialize device
    bRet = CDisk::Init(hActiveKey);
	//*(UINT32 *)(m_pATAReg + ATA_CFG) &= ~(0x40); // set little endian hsjang
    if (!bRet) {
        goto exit;
    }

exit:;
    return bRet;
}

// ----------------------------------------------------------------------------
// Function: MainIoctl
//     This is redundant
//
// Parameters:
//     pIOReq -
// ----------------------------------------------------------------------------

DWORD
CRomiDisk::MainIoctl(
    PIOREQ pIOReq
    )
{
    DEBUGMSG(ZONE_IOCTL, (_T(
        "Atapi!CRomiDisk::MainIoctl> IOCTL(%d), device(%d) \r\n"
        ), pIOReq->dwCode, m_dwDeviceId));

    return CDisk::MainIoctl(pIOReq);
}

// ----------------------------------------------------------------------------
// Function: ConfigPort
//     Initialize IST/ISR
//
// Parameters:
//     None
// ----------------------------------------------------------------------------

BOOL
CRomiDisk::ConfigPort(
    )
{
	int RetValue=TRUE;

    m_pATAReg = (PBYTE)m_pPort->m_dwRegBase;

    m_pATARegAlt = (PBYTE)m_pPort->m_dwRegAlt;
    m_pBMCommand = (PBYTE)m_pPort->m_dwBMR;

	m_dwIndirectMode = m_pPort->m_pDskReg[m_dwDeviceId]->dwIndirectMode;

	m_vpIOPORTRegs = (S3C6400_GPIO_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_GPIO, sizeof(S3C6400_GPIO_REG), FALSE);
	if (m_vpIOPORTRegs == NULL)
	{
		RETAILMSG(1,(TEXT("For m_vpIOPORTRegs: DrvLib_MapIoSpace() failed IOPORT!\r\n")));
		RetValue = FALSE;
	}

	m_vpSYSCONRegs = (S3C6400_SYSCON_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_SYSCON, sizeof(S3C6400_SYSCON_REG), FALSE);
	if (m_vpSYSCONRegs == NULL)
	{
		RETAILMSG(1,(TEXT("For m_vpSYSCONRegs: DrvLib_MapIoSpace() failed SYSCON!\r\n")));
		RetValue = FALSE;
	}

       // 2007.04.11 D.Baek
       // Notes :
       // Chip Selection signal in S3C6400 is controlled using "MEM_SYS_CFG" register in SYSCON.
       // MEM_SYS_CFG[5:4] = 2'b11 -> CFCON CS0, CFCON CS1
	m_vpSYSCONRegs->MEM_SYS_CFG |= ((m_vpSYSCONRegs->MEM_SYS_CFG & (~(0x3F<<0)))|(0x1<<5)|(0x1<<4));
	m_vpIOPORTRegs->GPBCON &= ~(0xF<<16);
	m_vpIOPORTRegs->GPBCON |= (4<<16);

	if ( m_dwIndirectMode == 1 )
	{
		m_vpSYSCONRegs->MEM_SYS_CFG &= ~(0x1<<14); // InDirectMode
		m_dwOPMode = IndirectMode;
		RETAILMSG(1,(TEXT("[CF-ATA] Mode : InDirect Mode\n")));
	}
	else
	{
		m_vpSYSCONRegs->MEM_SYS_CFG |= (0x1<<14); // Use independent CF interface (DirectMode)
		m_dwOPMode = DirectMode;
		RETAILMSG(1,(TEXT("[CF-ATA] Mode : Direct Mode\n")));
	}

	// 2007.04.11 D.Baek
	// Set the GPIO for CF_Data, CF_Addr, IORDY, IOWR, IORD, CE[0], and CE[1]
	// Details.
	// 1. GPKCON0[31:0]  - DATA_CF[7:0] -> 4'b0101
	// 2. GPKCON1[31:0]  - DATA_CF[15:8] -> 4'b0101
	// 3. GPLCON0[11:0]  - ADDR_CF[2:0] -> 4'b0110
	// 4. GPMCON[19:16] - IORDY_CF -> 4'b0110
	// 5. GPMCON[15:12] - IOWR_CF -> 4'b0110
	// 6. GPMCON[11:8]   - IORD_CF -> 4'b0110
	// 7. GPMCON[74]      - CE_CF[1] -> 4'b0110
	// 8. GPMCON[3:0]     - CE_CF[0] -> 4'b0110