pdsocket.cpp

S3C2440A的windows ce 5.0 bsp包

            tmp = ( UCHAR ) ( m_dwCSCIrq << 4 );
            tmp |= CFG_CARD_DETECT_ENABLE | CFG_READY_ENABLE;
            WritePCICRegister( nSocket, REG_STATUS_CHANGE_INT_CONFIG, tmp );
        }
        else
        {
            WritePCICRegister( nSocket, REG_STATUS_CHANGE_INT_CONFIG, 0 );
        }

        // PD6710 specific code to enable management interrupt(routed to -INTR)
        if( !m_fPollingMode )
        {
            WritePCICRegister( nSocket, REG_STATUS_CHANGE_INT_CONFIG, CFG_CARD_DETECT_ENABLE );
        }
        else
        {
            WritePCICRegister( nSocket, REG_STATUS_CHANGE_INT_CONFIG, 0 );
        }

        if( !m_fPollingMode )
        {
            // Enable Manage Interrupt
            tmp = ReadPCICRegister( nSocket, REG_INTERRUPT_AND_GENERAL_CONTROL );
            tmp |= INT_ENABLE_MANAGE_INT;
            WritePCICRegister( nSocket, REG_INTERRUPT_AND_GENERAL_CONTROL, tmp );
        }
    }

    // CreateIST Event
    m_hISTEvent = CreateEvent( 0, FALSE, FALSE, NULL );

    if( !m_fPollingMode )
    {
        // Run IST
        BOOL r = InterruptInitialize( m_dwCSCSysIntr, m_hISTEvent, 0, 0 );
        ASSERT( r );
    }

    return TRUE;
}

#ifdef DEBUG
VOID CPcmciaBusBridge::DumpAllRegisters()
{
    DEBUGMSG( ZONE_FUNCTION, ( TEXT( "Dumping all PCIC registers\r\n" ) ) );
    for( UINT8 nRegNum = 0; nRegNum < 0x40; nRegNum++ )
    {
        UINT8 val = ReadPCICRegister( 0, nRegNum );
        UINT8 val2 = ReadPCICRegister( 1, nRegNum );
        DEBUGMSG( ZONE_FUNCTION,
                  ( TEXT( "%02x: %02x %02x\r\n" ), nRegNum, val, val2 ) );
    }
    DEBUGMSG( ZONE_FUNCTION, ( TEXT( "Dump completed.\r\n" ) ) );
}
#endif

//
// Function to set the PCIC index register
//
VOID CPcmciaBusBridge::PCICIndex( UINT socket_num, UINT8  register_num )
{
    WRITE_PORT_UCHAR( m_PCICIndex,
                      ( UINT8 )( ( socket_num == 0 ? 0 : 0x40 ) | register_num ) );
}

//
// Function to write to the PCIC data register
//
VOID CPcmciaBusBridge::PCICDataWrite( UINT8 value )
{
    WRITE_PORT_UCHAR( m_PCICData, value );
}

//
// Function to read the PCIC data register
//
UINT8 CPcmciaBusBridge::PCICDataRead( VOID )
{
    return READ_PORT_UCHAR( m_PCICData );
}


//
// Verify the PCIC's REG_CHIP_REVISION
//
// This bit of code looks in the 82365 chip revision register (PCIC index 0)
// to see if a valid 82365 is in the system.  The original code only
// recognized the 83h silicon revision.  This indicates REV C silicon from
// Intel.  However, Intel also had a very popular rev B version, and that's
// what the integrated PCMCIA controller on the AMD ElanSC400 emulated.  The
// silicon revision register for that version returned 82h.
//
BOOL CPcmciaBusBridge::IsValidPCICSig( void )
{
    switch( m_vRevision = ReadPCICRegister( 0, REG_CHIP_REVISION ) )
    {
      case 0x82:
      case 0x83:
      case 0x84:
        // for newer chip - can handle 3.3v
        DEBUGMSG( 1,
                  ( TEXT( "PCMCIA:IsValidPCICSig Valid CHIP_REVISION detected = 0x%x at 0x%x\r\n" ),
                    m_vRevision,
                    m_PCICIndex ) );
        return TRUE;
    }
    DEBUGMSG( 1,
              ( TEXT( "PCMCIA:IsValidPCICSig Invalid CHIP_REVISION = 0x%x at 0x%x!!!\r\n" ),
                m_vRevision,
                m_PCICIndex ) );
    return FALSE;
}

//
// Function to get the initial settings from the registry
//
// NOTE: lpRegPath is assumed to be under HKEY_LOCAL_MACHINE
//
// Returns ERROR_SUCCESS on success or a Win32 error code on failure
//
DWORD CPcmciaBusBridge::GetRegistryConfig()
{
    DWORD dwRet = 1;
    DWORD dwSize, dwType, dwData;

    // get the PCMCIA windows configuration
    if( !LoadWindowsSettings() )
    {
        dwRet = ERROR_INVALID_DATA;
        goto grc_fail;
    }

    // get the polling mode value
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( POLLING_MODE_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        m_fPollingMode = TRUE; // RegQueryValueEx failed, default to TRUE
    }
    else
    {
        m_fPollingMode = dwData ? TRUE : FALSE;
    }

    // get function interrupt routing configuration
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( IRQ_VALUE_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        DEBUGMSG( ZONE_PDD,
                  ( TEXT( "PCMCIA:GetRegistyConfig RegQueryValueEx(%s) failed\r\n" ),
                    IRQ_VALUE_NAME ) );
        goto grc_fail;
    }
    m_dwIrq = dwData;

    m_dwCSCSysIntr = 0;
    m_dwCSCIrq = 0;
    if( !m_fPollingMode )
    {
        // get card status change interrupt routing configuration
        dwSize = sizeof( DWORD );
        if( !RegQueryValueEx( CSC_IRQ_VALUE_NAME,
                              &dwType,
                              ( PUCHAR ) & dwData,
                              &dwSize ) )
        {
            m_fPollingMode = TRUE;
        }
        else
        {
            m_dwCSCIrq = dwData;
        }
        dwSize = sizeof( DWORD );
        if( !RegQueryValueEx( CSC_SYSINTR_VALUE_NAME,
                              &dwType,
                              ( PUCHAR ) & dwData,
                              &dwSize ) )
        {
            m_fPollingMode = TRUE;
        }
        else
        {
            m_dwCSCSysIntr = dwData;
        }
    }

    // get the polling timeout value
    dwSize = sizeof( DWORD );
    if( !RegQueryValueEx( POLL_TIMEOUT_NAME,
                          &dwType,
                          ( PUCHAR ) & dwData,
                          &dwSize ) )
    {
        // RegQueryValueEx failed; if polling, set the timeout to 0.5 sec, otherwise set to INFINITE
        m_dwPollTimeout = m_fPollingMode ? 500 : INFINITE;
    }
    else
    {
        m_dwPollTimeout = dwData;
    }

    dwRet = ERROR_SUCCESS;

    grc_fail : return dwRet;
}   // GetRegistryConfig

BOOL CPcmciaBusBridge::InitCardBusBridge( void )
{
    DWORD dwRet;

    // Create critical section protecting the PCIC registers
    __try
    {
        InitializeCriticalSection( &m_PCICCritSec );
    }
    __except( EXCEPTION_EXECUTE_HANDLER )
    {
        DEBUGMSG( ZONE_PDD,
                  ( TEXT( "PDCardInitServices InitializeCriticalSection failed %d\r\n" ) ) );
        return FALSE;
    }
    m_fPCICCritSecInitialized = true;

    // Get registry information
    if( ( dwRet = GetRegistryConfig() ) != ERROR_SUCCESS )
    {
        DEBUGMSG( ZONE_PDD,
                  ( TEXT( "PDCardInitServices GetRegistryConfig failed %d\r\n" ),
                    dwRet ) );
        return FALSE;
    }

    // Convert the data interrupt to a logical sysintr value.
    //
    if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &m_dwIrq, sizeof(DWORD), &m_dwSysIntr, sizeof(DWORD), NULL))
    {
        RETAILMSG(1, (TEXT("PCMCIA: Failed to obtain sysintr value for data interrupt.\r\n")));
        m_dwSysIntr = SYSINTR_UNDEFINED;
        return FALSE;
    }

	// Allocate PCMCIA buffers.
	m_vpIOPRegs = (S3C2440A_IOPORT_REG*)VirtualAlloc(0, sizeof(S3C2440A_IOPORT_REG), MEM_RESERVE, PAGE_NOACCESS);
	if (m_vpIOPRegs == NULL) 
	{
		DEBUGMSG (1,(TEXT("m_vpIOPRegs is not allocated\n\r")));
		goto pcis_fail;
	}
	if (!VirtualCopy((PVOID)m_vpIOPRegs, (PVOID)(S3C2440A_BASE_REG_PA_IOPORT >> 8), sizeof(S3C2440A_IOPORT_REG), PAGE_PHYSICAL|PAGE_READWRITE|PAGE_NOCACHE)) {
		DEBUGMSG (1,(TEXT("m_vpIOPRegs is not mapped\n\r")));
		goto pcis_fail;
	}
	DEBUGMSG (1,(TEXT("m_vpIOPRegs is mapped to %x\n\r"), m_vpIOPRegs));
	
	m_vpMEMRegs = (S3C2440A_MEMCTRL_REG*)VirtualAlloc(0,sizeof(S3C2440A_MEMCTRL_REG), MEM_RESERVE,PAGE_NOACCESS);
	if(m_vpMEMRegs == NULL) 
	{
		DEBUGMSG (1,(TEXT("m_vpMEMRegs is not allocated\n\r")));
		goto pcis_fail;
	}
	if(!VirtualCopy((PVOID)m_vpMEMRegs,(PVOID)(S3C2440A_BASE_REG_PA_MEMCTRL >> 8),sizeof(S3C2440A_MEMCTRL_REG), PAGE_PHYSICAL|PAGE_READWRITE|PAGE_NOCACHE)) {

		DEBUGMSG (1,(TEXT("m_vpMEMRegs is not mapped\n\r")));
		goto pcis_fail;
	}    
	DEBUGMSG (1,(TEXT("m_vpMEMRegs is mapped to %x\n\r"), m_vpMEMRegs));

	m_vpPCMCIAPort = (PUCHAR*)VirtualAlloc(0, 0x0400, MEM_RESERVE,PAGE_NOACCESS);
	if(m_vpPCMCIAPort == NULL) 
	{
		DEBUGMSG (1,(TEXT("m_vpPCMCIAPort is not allocated\n\r")));
		goto pcis_fail;
	}
	if(!VirtualCopy((PVOID)m_vpPCMCIAPort,(PVOID)PD6710_IO_BASE_ADDRESS, 0x0400, PAGE_READWRITE|PAGE_NOCACHE)) {
		DEBUGMSG (1,(TEXT("m_vpPCMCIAPort is not mapped\n\r")));
		goto pcis_fail;
	}    
	DEBUGMSG (1,(TEXT("m_vpPCMCIAPort is mapped to %x\n\r"), m_vpPCMCIAPort));
	
	// Initialize S3C2440 for PD6710           
	// EINT3(GPF3) is enabled.
	m_vpIOPRegs->GPFCON = (m_vpIOPRegs->GPFCON & ~(0x3<<6)) | (0x2<<6); 
	// EINT3 is PULLUP enabled.
	m_vpIOPRegs->GPFUP = (m_vpIOPRegs->GPFUP & ~(0x1<<3));              

	// EINT8(GPG0) is enabled.
	m_vpIOPRegs->GPGCON = (m_vpIOPRegs->GPGCON & ~(0x3<<0)) | (0x2<<0); 
	// EINT8 is *not* PULLUP enabled.
	m_vpIOPRegs->GPGUP = (m_vpIOPRegs->GPGUP | (0x1<<0));

	
	// nGCS2=nUB/nLB(nSBHE),nWAIT,16-bit
	m_vpMEMRegs->BWSCON = (m_vpMEMRegs->BWSCON & ~(0xf<<8)) | (0xd<<8); 

	// BANK2 access timing
	m_vpMEMRegs->BANKCON2 = ((B6710_Tacs<<13)+(B6710_Tcos<<11)+(B6710_Tacc<<8)+(B6710_Tcoh<<6)\
		+(B6710_Tah<<4)+(B6710_Tacp<<2)+(B6710_PMC));

	
	// EINT8=Level-high triggered, IRQ3.
	// EINT3=Falling Edge triggering -> connected INTR(controller)
	m_vpIOPRegs->EXTINT1=(m_vpIOPRegs->EXTINT1 & ~(0xf<<0)) | (0x1<<0); 
	m_vpIOPRegs->EXTINT0=(m_vpIOPRegs->EXTINT0 & ~(0xf<<12)) | (0x2<<12); 
		
	m_PCICIndex = ((PUCHAR)((ULONG)m_vpPCMCIAPort+0x3e0));
	m_PCICData = ((PUCHAR)((ULONG)m_vpPCMCIAPort+0x3e1));

	DEBUGMSG(1, (TEXT("PDCardInitServices m_PCICIndex = 0x%x, m_PCICData = 0x%x\r\n"),
		          m_PCICIndex, m_PCICData));

    if( !IsValidPCICSig() )
    {
        return FALSE;
    }

    DEBUGMSG( ZONE_PDD,
              ( TEXT( "PDCardInitServices m_PCICIndex = 0x%x, m_PCICData = 0x%x\r\n" ),
                m_PCICIndex,
                m_PCICData ) );

    UINT8 tmp = ReadPCICRegister( 0, REG_CHIP_REVISION );
    DEBUGMSG( ZONE_PDD,
              ( TEXT( "PDCardInitServices REG_CHIP_REVISION = 0x%x\r\n" ),
                tmp ) );

    DDKISRINFO ddi;
    if( GetIsrInfo( &ddi ) != ERROR_SUCCESS )
    {
        return FALSE;
    }

    InstallIsr();

    return TRUE;

pcis_fail:
    return FALSE;
}