pdsocket.cpp

S3C2440A的windows ce 5.0 bsp包

#define DEFAULT_PRIORITY 101

BOOL CPcmciaBusBridge::Init()
{
    if( !loadPcCardEntry() )
    {
        return FALSE;
    }
    if( !InitCardBusBridge() )
    {
        return FALSE;
    }

    for( UINT8 nSocket = GetSocketLowBound();
         nSocket <= GetSocketHighBound();
         nSocket++ )
    {
        if( !GetSocketNumberFromCS( nSocket, TRUE ) )
        {
            for( UINT nTmp = GetSocketLowBound(); nTmp < nSocket; nTmp++ )
            {
                GetSocketNumberFromCS( nSocket, FALSE );
                m_rguSocketNum[nSocket] = ( UINT16 ) - 1;
            }
            return FALSE;
        }
    }

    // Set Tread Priority.
    m_uPriority = DEFAULT_PRIORITY;
    DWORD dwRegPriority = 0;
    if( GetRegValue( RegPriority256,
                     ( PBYTE ) & dwRegPriority,
                     sizeof( dwRegPriority ) ) )
    {
        m_uPriority = ( UINT ) dwRegPriority;
    }
    // Get Thread Priority from Registry and Set it.
    CeSetPriority( m_uPriority );
    m_bTerminated = FALSE;

    ThreadStart();
    return TRUE;
}
BOOL CPcmciaBusBridge::GetRegPowerOption( PDWORD pOption )
{
    if( pOption )
    {
        return GetRegValue( RegPowerOption,
                            ( PBYTE ) pOption,
                            sizeof( DWORD ) );
    }
    return TRUE;
}
void CPcmciaBusBridge::PowerMgr( BOOL bPowerDown )
{
    if( bPowerDown )
    {
        for( UINT8 nSocket = GetSocketLowBound();
            nSocket <= GetSocketHighBound();
            nSocket++ )
        {
            if( m_prgCardSocket[nSocket] )
            {
                // Disable client interrupts
                WritePCICRegister( nSocket, REG_INTERRUPT_AND_GENERAL_CONTROL,
                    ReadPCICRegister( nSocket, REG_INTERRUPT_AND_GENERAL_CONTROL ) & 0xf0 );
                // Shut down socket any way.
                WritePCICRegister( nSocket, REG_POWER_CONTROL, 0 );
            }
        }
    }
    else
    {
        // 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); 

        for( UINT8 nSocket = GetSocketLowBound();
            nSocket <= GetSocketHighBound();
            nSocket++ )
        {
            if( m_prgCardSocket[nSocket] )
            {
                CardInjectEvent( nSocket );
            }
        }
    } 
}

BOOL CPcmciaBusBridge::NeedPowerResuming()
{
    m_bResumeFlag = TRUE;
    SetInterruptEvent( m_dwCSCSysIntr );
    return TRUE;
}

void CPcmciaBusBridge::PowerCycleEvent( UINT8 nSocket )
{
    Lock();
    m_rgfPowerCycleEvent[nSocket] = TRUE;
    SetEvent( m_hISTEvent );
    Unlock();
}

void CPcmciaBusBridge::CardInjectEvent( UINT8 nSocket )
{
    Lock();
    m_rgfCardInjectEvent[nSocket] = TRUE;
    SetEvent( m_hISTEvent );
    Unlock();
}

DWORD CPcmciaBusBridge::ThreadRun() // THIS is CardBusBridge IST.
{
    // Test if a PCMCIA card is already inserted in one of the sockets
    bool fCardAlreadyInserted = false;
    DWORD dwOldCardStatus[NUM_SLOTS];
    bool frgCardAlreadyInserted[NUM_SLOTS];
    for( int nSocket = GetSocketLowBound();
         nSocket <= GetSocketHighBound();
         nSocket++ )
    {
        frgCardAlreadyInserted[nSocket] = false;
        if( ( ReadPCICRegister( nSocket, REG_INTERFACE_STATUS ) 
                & ( STS_CD1 | STS_CD2 ) ) == ( STS_CD1 | STS_CD2 ) )
        {
            frgCardAlreadyInserted[nSocket] = true;
            fCardAlreadyInserted = true;
            dwOldCardStatus[nSocket] = ( STS_CD1 | STS_CD2 );
        }
        else
        {
            dwOldCardStatus[nSocket] = 0;
        }
    }

    // run until signalled to terminate
    while( !m_bTerminated )
    {
        DEBUGCHK(m_hISTEvent!=NULL);
        BOOL bInterrupt;
        if( !fCardAlreadyInserted )
        {
            bInterrupt = (WaitForSingleObject(m_hISTEvent,m_dwPollTimeout)!=WAIT_TIMEOUT);
            if( m_fPollingMode ) // we are polling, fake an interrupt event
            {
                bInterrupt = true;
            }
        }
        else
        {
            bInterrupt = true;
        }

        if (!bInterrupt) { // we have reached a timeout in non-polling mode or something bad has occured.
            continue;
        }

        Lock();

        // check each card slot for changes
        for( UINT8 nSocket = GetSocketLowBound();
             nSocket <= GetSocketHighBound();
             nSocket++ )
        {
            UINT8 BSocketState, bCardStatusChange;
            UINT8 fNotifyEvents = 0;

            if( !m_fPollingMode )
            {
                // See what changed and acknowledge any status change interrupts
                bCardStatusChange = ReadPCICRegister( nSocket,
                                                REG_CARD_STATUS_CHANGE );
            }
            else
            {
                // Get the current card status and compare it to the previous status
                DWORD newStatus = ReadPCICRegister( nSocket, REG_INTERFACE_STATUS ) & ( STS_CD1 | STS_CD2 );
                bCardStatusChange = ( newStatus != dwOldCardStatus[nSocket] ) ? CSC_DETECT_CHANGE : 0;
                dwOldCardStatus[nSocket] = newStatus;
            }

            // if nothing has changed, continue to the next slot
            if( !frgCardAlreadyInserted[nSocket] &&
                !m_rgfPowerCycleEvent[nSocket] &&
                !m_rgfCardInjectEvent[nSocket] &&
                bCardStatusChange == 0x0 )
            {
                continue;
            }

            //
            // Figure out the socket state
            //
            BSocketState = ReadPCICRegister( nSocket, REG_INTERFACE_STATUS );

            if( frgCardAlreadyInserted[nSocket] )
            {
                bCardStatusChange |= CSC_DETECT_CHANGE;
                frgCardAlreadyInserted[nSocket] = false;
            }

            if( bCardStatusChange & CSC_DETECT_CHANGE )
            {
                fNotifyEvents |= EVENT_MASK_CARD_DETECT;
            }

            if( m_rgfCardInjectEvent[nSocket] )
            {
                fNotifyEvents |= EVENT_MASK_CARD_DETECT;
                m_rgfCardInjectEvent[nSocket] = FALSE;
            }

            if( m_rgfPowerCycleEvent[nSocket] )
            {
                fNotifyEvents |= SPS_POWERCYCLE;
                m_rgfPowerCycleEvent[nSocket] = FALSE;
            }

            if( fNotifyEvents & EVENT_MASK_CARD_DETECT )
            {
                // we're only processing Card Detection Signal.
                // If this happens, Something has been changed. 
                // Send out Card revmoval before doing any more process.
                RemovePcmciaCardSocket( nSocket );
                ProcessCDD( nSocket, BSocketState );
            }
            else
            {
                // Other Event left for type specific socket
                if( m_prgCardSocket[nSocket] )
                    m_prgCardSocket[nSocket]->SocketEventHandle( bCardStatusChange,
                                                                 fNotifyEvents );
            }
        } // for

        Unlock();
        fCardAlreadyInserted = false;

        if( !m_fPollingMode )
        {
            DEBUGMSG( ZONE_FUNCTION,
                      ( L"CardBus: PCCardBus Call InterruptDone\r\n" ) );
            InterruptDone( m_dwCSCSysIntr );
        }
    } // while(!m_bTerminated) 
    return 0;
}

void CPcmciaBusBridge::ProcessCDD( UINT nSocketNumber, DWORD dwPStateReg )
{
    switch( dwPStateReg & ( STS_CD1 | STS_CD2 ) )
    {
      case 0x0:
        // Complete removal
        if( m_prgCardSocket[nSocketNumber] )
        {
            RemovePcmciaCardSocket( nSocketNumber );
        }
        // Socket Detached.

        break;
      case (STS_CD1|STS_CD2):
        // Complete Insertion.
        if( m_prgCardSocket[nSocketNumber] == NULL )
        {
            InsertPcmciaCardSocket( CreatePCMCIASocket( this, nSocketNumber ),
                                    nSocketNumber );
        }
        break;
      default:
        break;
    }
}

void CPcmciaBusBridge::CallBackToCardService( UINT8 nSocket,
                                              HANDLE hSocket,
                                              PSS_SOCKET_STATE pSocketState )
{
    if( m_pCallBackToCardService )
    {
        __try
        {
            m_pCallBackToCardService( hSocket,
                                      m_rguSocketNum[nSocket],
                                      pSocketState );
        } __except( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGCHK( FALSE );
        }
    }
    else
    {
        DEBUGCHK( FALSE );
    }
}
BOOL CPcmciaBusBridge::GetSocketNumberFromCS( UINT8 nSocket, BOOL bGet )
{
    STATUS status = CERR_BAD_ARGS;
    if( m_pRequestSocketNumber && m_pDeleteSocket )
    {
        __try
        {
            status = ( bGet ?
                       m_pRequestSocketNumber( &m_rguSocketNum[nSocket],
                                               sizeof( SMDK2440SocketServiceStatic ),
                                               &SMDK2440SocketServiceStatic,
                                               GetSocketName() ) :
                       m_pDeleteSocket( m_rguSocketNum[nSocket] ) );
        } __except( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGCHK( FALSE );
            status = CERR_BAD_ARGS;
        }
    }
    DEBUGCHK( status == CERR_SUCCESS );
    return ( status == CERR_SUCCESS );
}