pcmciawin.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

/*
 *
 * Copyright (C) 2003-2004, MOTOROLA, INC. All Rights Reserved
 * THIS SOURCE CODE IS CONFIDENTIAL AND PROPRIETARY AND MAY NOT
 * BE USED OR DISTRIBUTED WITHOUT THE WRITTEN PERMISSION OF
 * MOTOROLA, INC.
 *
 * Copyright (C) 2004-2006, Freescale Semiconductor, Inc. All Rights Reserved.
 * THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
 * AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT 
 *
 */
 
#define __PCMCIAWIN_CPP__
#include "pcmciawin.h"


CPcmciaMemWindows::CPcmciaMemWindows( CPcmciaSocket* pPcmSocket,
                                      DWORD dwWinIndex,
                                      const SS_WINDOW_STATE* pcWindowState,
                                      const SS_WINDOW_INFO* pcWindowInfo ) : CPcmciaMemWindowImpl<CPcmciaSocket>( pPcmSocket,
                                                                                                               dwWinIndex,
                                                                                                               pcWindowState,
                                                                                                               pcWindowInfo )
{	
	DEBUGMSG(ZONE_PDD,(TEXT("++CPcmciaMemWindows::CPcmciaMemWindows[%d]\r\n"),dwWinIndex));
	// Base & Offset Address of uWindow
	g_vPcmciaReg->PBR[dwWinIndex] = pcWindowInfo->uMemFirstByte;
    	m_dwBaseAddress = pcWindowInfo->uMemFirstByte; // save the 1st memory window base address
    	Initialize();    
}

CPcmciaMemWindows::~CPcmciaMemWindows()
{
    Deinitialize();
}

void CPcmciaMemWindows::FreeResources()
{
}

void CPcmciaMemWindows::DisableWindow()
{
	DEBUGMSG(ZONE_PDD,(TEXT("++CPcmciaMemWindows::DisableWindow [%d]\r\n"),m_dwWinIndex));
	
	g_vPcmciaReg->POR[m_dwWinIndex] &= ~PCMCIA_POR_PVALID;	
}

void CPcmciaMemWindows::ProgramWindow()
{
	UINT32	tmp;
	UINT32 i;
	UINT32 bankSizeValue;
	
	DEBUGMSG(ZONE_PDD,(TEXT("++CPcmciaMemWindows::ProgramWindow [%d]\r\n"),m_dwWinIndex));
	
	// Disable this window while we work on it.
	g_vPcmciaReg->POR[m_dwWinIndex] &= ~PCMCIA_POR_PVALID;
	
	// Base & Offset Address of uWindow
	DEBUGMSG(ZONE_PDD,(TEXT("\tOriginal request, uBase: 0x%X, uOffset:0x%X\n\r"),m_WinStatus.uBase,m_WinStatus.uOffset));
	DEBUGMSG(ZONE_PDD,(TEXT("\tDue to add limitation, new uBase: 0x%X, uOffset:0x%X\n\r"),
								m_WinStatus.uBase&PCMCIA_ADDRESS_OFFSET_MASK,m_WinStatus.uOffset&PCMCIA_ADDRESS_OFFSET_MASK));
	g_vPcmciaReg->PBR[m_dwWinIndex] = m_WinStatus.uBase & PCMCIA_ADDRESS_OFFSET_MASK;
	g_vPcmciaReg->POFR[m_dwWinIndex] = m_WinStatus.uOffset & PCMCIA_ADDRESS_OFFSET_MASK;    	

	// starting TO3, BSIZE needs to be >=16 bytes
	if (m_WinStatus.uSize < PCMCIA_BANKSIZE_MIN)
		m_WinStatus.uSize = PCMCIA_BANKSIZE_MIN; 

	i=0;
	while(TRUE) {
		tmp=(UINT32) ( 1 << ( i + PCMCIA_BSIZE_BIT_OFFSET) );
		// Instead of return Bad Window, we give size bigger than requested
		if (m_WinStatus.uSize <= tmp) {
			bankSizeValue = g_bankSizeValue[i];
			break;
		} else if ( tmp > PCMCIA_BANKSIZE_MAX) {
			return;
		} else {
			i++;
		}
	}	
			
	// Write BankSize for window size
	tmp=(bankSizeValue << PCMCIA_POR_BSIZE_BS);
		
	if(PCMCIA_BANKSIZE_MIN >= 16) {
		// force to 16 bit access since it's 16bit data allignment
		m_WinStatus.fState |= WIN_STATE_16BIT;
	} else if(!(m_WinStatus.fState & WIN_STATE_16BIT)) {
		// set 8 bit mode
		tmp	|= (PCMCIA_PORTSIZE_8BIT << PCMCIA_POR_PORTSIZE_BS);
	} 
	
	// set memory window as common or attribute
	if(m_WinStatus.fState & WIN_STATE_ATTRIBUTE) {
		tmp	|= (PCMCIA_REGIONSELECT_ATTRIBUTE << PCMCIA_POR_REGIONSELECT_BS);
	} else {
		tmp	|= (PCMCIA_REGIONSELECT_COMMON << PCMCIA_POR_REGIONSELECT_BS);
	}
		
	// Set strobe timing
	tmp |= ( PCMCIA_POR_PSL_BS_DEFAULT << PCMCIA_POR_PSL_BS);
	tmp |= ( PCMCIA_POR_PSST_BS_DEFAULT << PCMCIA_POR_PSST_BS);
	tmp |= ( PCMCIA_POR_PSHT_BS_DEFAULT << PCMCIA_POR_PSHT_BS);				
				
	g_vPcmciaReg->POR[m_dwWinIndex] = tmp;

	//
	// Enable or disable this window as requested.
	//
	if (m_WinStatus.fState & WIN_STATE_ENABLED) 
	{
		g_vPcmciaReg->POR[m_dwWinIndex] |= PCMCIA_POR_PVALID;
		Sleep(100);
	} 
	else 
	{		
		g_vPcmciaReg->POR[m_dwWinIndex] &= ~PCMCIA_POR_PVALID;
	}	

#ifdef DEBUG
	PcPrintPcmciaReg();
#endif

}

DWORD CPcmciaMemWindows::GetNewOffset( PSS_WINDOW_STATE pWindowState )
{

    // alignment with the minimum size allocation
    DWORD dwNewOffset = pWindowState->uOffset & (~(m_WinInfo.uMemMinSize-1));
	DEBUGMSG(ZONE_PDD,(TEXT("CPcmciaMemWindows::GetNewOffset [%d]: newOffset:0x%X\r\n"),m_dwWinIndex,dwNewOffset));	

    return dwNewOffset;
}

DWORD CPcmciaMemWindows::GetNewLength( PSS_WINDOW_STATE pWindowState,
                                       DWORD dwNewOffset )
{
	// compensate the new offset
    DWORD dwNewLength = 	pWindowState->uOffset +
                        				pWindowState->uSize -
                        				dwNewOffset ;			

	// alignment with minimum size
	if(dwNewLength %m_WinInfo.uMemMinSize)
		dwNewLength += m_WinInfo.uMemMinSize - dwNewLength %m_WinInfo.uMemMinSize;
	DEBUGMSG(ZONE_PDD,(TEXT("CPcmciaMemWindows::GetNewLength [%d]: dwNewLength:0x%X\r\n"),m_dwWinIndex,dwNewLength));	

    return dwNewLength;
}

BOOL CPcmciaMemWindows::GetBaseAddress( PSS_WINDOW_STATE pWindowState,
                                        DWORD dwNewOffset,
                                        DWORD dwNewLength,
                                        DWORD& dwNewBaseAddress )
{
	dwNewBaseAddress = m_dwBaseAddress;	
 	DEBUGMSG(ZONE_PDD,(TEXT("CPcmciaMemWindows::GetBaseAddress [%d]: m_dwBaseAddress:0x%X\r\n"),m_dwWinIndex,m_dwBaseAddress));	
   	return TRUE;
}

CPcmciaIoWindows::CPcmciaIoWindows( CPcmciaSocket* pPcmSocket,
                                    DWORD dwWinIndex,
                                    const SS_WINDOW_STATE* pcWindowState,
                                    const SS_WINDOW_INFO* pcWindowInfo ) : CPcmciaIoWindowImpl<CPcmciaSocket>( pPcmSocket,
                                                                                                            dwWinIndex,
                                                                                                            pcWindowState,
                                                                                                            pcWindowInfo )
{	
	DEBUGMSG(ZONE_PDD,(TEXT("++CPcmciaIoWindows::CPcmciaIoWindows[%d]\r\n"),dwWinIndex));	
	m_dwOffset = 0;
	m_dwBaseAddress = pcWindowInfo->uIOFirstByte;
	Initialize();
}

CPcmciaIoWindows::~CPcmciaIoWindows()
{
    Deinitialize();
}

void CPcmciaIoWindows::FreeResources()
{
}

void CPcmciaIoWindows::DisableWindow()
{
	UINT32 dwIoIndex = m_dwWinIndex + PCMCIA_NUM_MEMWIN;

	DEBUGMSG(ZONE_PDD,(TEXT("++CPcmciaIoWindows::DisableWindow [%d]\r\n"),m_dwWinIndex));	
	g_vPcmciaReg->POR[dwIoIndex] &= ~PCMCIA_POR_PVALID;	
}

void CPcmciaIoWindows::ProgramWindow()
{
	UINT32 tmp;
	UINT32 i;
	UINT32 bankSizeValue;
	UINT32 dwIoIndex = m_dwWinIndex + PCMCIA_NUM_MEMWIN;
	
	DEBUGMSG(ZONE_PDD,(TEXT("++CPcmciaIoWindows::ProgramWindow [%d]\r\n"),m_dwWinIndex));

	// Disable this	window while we	work on	it.
	g_vPcmciaReg->POR[dwIoIndex] &= ~PCMCIA_POR_PVALID;			

	// Base & Offset Address of uWindow
	DEBUGMSG(ZONE_PDD,(TEXT("\tOriginal request, uBase: 0x%X, uOffset:0x%X\n\r"),m_WinStatus.uBase,m_WinStatus.uOffset));
	DEBUGMSG(ZONE_PDD,(TEXT("\tDue to add limitation, new uBase: 0x%X, uOffset:0x%X\n\r"),
								m_WinStatus.uBase&PCMCIA_ADDRESS_OFFSET_MASK,m_WinStatus.uOffset&PCMCIA_ADDRESS_OFFSET_MASK));
	g_vPcmciaReg->PBR[dwIoIndex] = m_WinStatus.uBase & PCMCIA_ADDRESS_OFFSET_MASK;
	g_vPcmciaReg->POFR[dwIoIndex] = m_WinStatus.uOffset & PCMCIA_ADDRESS_OFFSET_MASK;
	
	// set to min bank size if the requested size is smaller
	if (m_WinStatus.uSize < PCMCIA_BANKSIZE_MIN) {
		m_WinStatus.uSize = PCMCIA_BANKSIZE_MIN;
	}	

	i=0;
	while(TRUE) {
		tmp=(UINT32) ( 1 << (i + PCMCIA_BSIZE_BIT_OFFSET) );
		// Instead of return Bad Window, we give size bigger than requested
		if (m_WinStatus.uSize <= tmp) {
			bankSizeValue = g_bankSizeValue[i];
			break;
		} else if ( tmp > PCMCIA_BANKSIZE_MAX) {
			return;
		} else {
			i++;
		}
	}			
			
	// Write BankSize for window size
	tmp=(bankSizeValue << PCMCIA_POR_BSIZE_BS);
		
	// Set Port Size
	
#if (MX21_TO_VER >= 30)
	// force to 16 bit access since banksize can't be smaller than 16B
	m_WinStatus.fState |= WIN_STATE_16BIT;
	tmp	|= (PCMCIA_PORTSIZE_16BIT << PCMCIA_POR_PORTSIZE_BS);

#else
	if(!(m_WinStatus.fState & WIN_STATE_16BIT))	
	{
		tmp	|= (PCMCIA_PORTSIZE_8BIT << PCMCIA_POR_PORTSIZE_BS);		
	}
	else
	{
		tmp	|= (PCMCIA_PORTSIZE_16BIT << PCMCIA_POR_PORTSIZE_BS);
	}

#endif
				
	// set as IO mode
	tmp	|= (PCMCIA_REGIONSELECT_IO << PCMCIA_POR_REGIONSELECT_BS);
	
	// Set strobe timing
	tmp |= ( PCMCIA_POR_PSL_BS_DEFAULT << PCMCIA_POR_PSL_BS);
	tmp |= ( PCMCIA_POR_PSST_BS_DEFAULT << PCMCIA_POR_PSST_BS);
	tmp |= ( PCMCIA_POR_PSHT_BS_DEFAULT << PCMCIA_POR_PSHT_BS);				
			
	// Now write to POR register
	g_vPcmciaReg->POR[dwIoIndex] = tmp;
			
	//
	// Enable or disable this window as	requested.
	//
	if (m_WinStatus.fState & WIN_STATE_ENABLED) {
		g_vPcmciaReg->POR[dwIoIndex] |= PCMCIA_POR_PVALID;
		Sleep(100);
	} else {		
		g_vPcmciaReg->POR[dwIoIndex] &= ~PCMCIA_POR_PVALID;
	}		

#ifdef DEBUG
	PcPrintPcmciaReg();
#endif
}

DWORD CPcmciaIoWindows::GetNewOffset( PSS_WINDOW_STATE pWindowState )
{
	// alignment with the minimum size allocation
	DWORD dwNewOffset = pWindowState->uOffset & (~(m_WinInfo.uIOMinSize-1));
	
	DEBUGMSG(ZONE_PDD,(TEXT("CPcmciaIoWindows::GetNewOffset [%d]: newOffset:0x%X\r\n"),m_dwWinIndex,dwNewOffset));	

	 return dwNewOffset;
}

DWORD CPcmciaIoWindows::GetNewLength( PSS_WINDOW_STATE pWindowState,
                                      DWORD dwNewOffset )
{
	// compensate the new offset
    DWORD dwNewLength = 	pWindowState->uOffset +
                        				pWindowState->uSize -
                        				dwNewOffset ;			

	// alignment with minimu size
	if(dwNewLength %m_WinInfo.uIOMinSize)
		dwNewLength += m_WinInfo.uIOMinSize - dwNewLength %m_WinInfo.uIOMinSize;
	DEBUGMSG(ZONE_PDD,(TEXT("CPcmciaIoWindows::GetNewLength [%d]: dwNewLength:0x%X\r\n"),m_dwWinIndex,dwNewLength));	

	return dwNewLength;
}

BOOL CPcmciaIoWindows::GetBaseAddress( PSS_WINDOW_STATE pWindowState,
                                       DWORD dwNewOffset,
                                       DWORD dwNewLength,
                                       DWORD& dwNewBaseAddress )
{
	DEBUGMSG(ZONE_PDD,(TEXT("CPcmciaIoWindows::GetBaseAddress [%d]: m_dwBaseAddress:0x%X\r\n"),m_dwWinIndex,m_dwBaseAddress));	

	dwNewBaseAddress = m_dwBaseAddress;
       return TRUE;
}