testintr.cxx

eCos/RedBoot for勤研ARM AnywhereII(4510) 含全部源代码

        ercd = set_flg( 2, 0xfff );
        CYG_TEST_CHECK( E_OK == ercd, "set_flg(2) bad ercd" );
        ercd = set_flg( 3, 0xfff );
        CYG_TEST_CHECK( E_OK == ercd, "set_flg(3) bad ercd" );
        ercd = set_flg( 4, 0xfff );
        CYG_TEST_CHECK( E_OK == ercd, "set_flg(4) bad ercd" );
        
        CYG_TEST_CHECK(              0 == wakeups[0], "set_flg: Wakeups[0] hit" );
        CYG_TEST_CHECK(              0 == wakeups[1], "set_flg: Wakeups[1] hit" );
        CYG_TEST_CHECK( prewups[2] + 1 == wakeups[2], "set_flg: Wakeups[2] not hit" );
        CYG_TEST_CHECK( prewups[3] + 1 == wakeups[3], "set_flg: Wakeups[3] not hit" );
        CYG_TEST_CHECK( prewups[4] + 1 == wakeups[4], "set_flg: Wakeups[4] not hit" );
        prewups[2] = wakeups[2];
        prewups[3] = wakeups[3];
        prewups[4] = wakeups[4];
        
        // -------- TIMERS AND TIMESLICING DISABLED ---------
        // install an isr that will wake them all up in turn
        attach_isr( isr_snd_msg );
        DELAY();
        detach_isr( isr_snd_msg );
        // -------- timers and timeslicing ENABLED ---------

        CYG_TEST_CHECK(         0 == wakeups[0], "isnd_msg: Wakeups[0] hit" );
        CYG_TEST_CHECK(         0 == wakeups[1], "isnd_msg: Wakeups[1] hit" );
        CYG_TEST_CHECK( prewups[2] < wakeups[2], "isnd_msg: Wakeups[2] not hit" );
        CYG_TEST_CHECK( prewups[3] < wakeups[3], "isnd_msg: Wakeups[3] not hit" );
        CYG_TEST_CHECK( prewups[4] < wakeups[4], "isnd_msg: Wakeups[4] not hit" );
        diag_printf( "INFO:<(fg loops %10d) message rec'pts: %2d %2d %2d >\n", count,
                     wakeups[2] - prewups[2],
                     wakeups[3] - prewups[3],
                     wakeups[4] - prewups[4] );
        prewups[2] = wakeups[2];
        prewups[3] = wakeups[3];
        prewups[4] = wakeups[4];

        // move them on to exiting, all done
        if ( 1 == loops )
            // then we are about to exit
            intercom = EXIT;
        else
            intercom = SLP;
        ercd = snd_msg( 2, (T_MSG *)&intercom );
        CYG_TEST_CHECK( E_OK == ercd, "snd_msg(2) bad ercd" );
        ercd = snd_msg( 3, (T_MSG *)&intercom );
        CYG_TEST_CHECK( E_OK == ercd, "snd_msg(3) bad ercd" );
        ercd = snd_msg( 4, (T_MSG *)&intercom );
        CYG_TEST_CHECK( E_OK == ercd, "snd_msg(4) bad ercd" );

        CYG_TEST_CHECK(              0 == wakeups[0], "snd_msg: Wakeups[0] hit" );
        CYG_TEST_CHECK(              0 == wakeups[1], "snd_msg: Wakeups[1] hit" );
        CYG_TEST_CHECK( prewups[2] + 1 == wakeups[2], "snd_msg: Wakeups[2] not hit" );
        CYG_TEST_CHECK( prewups[3] + 1 == wakeups[3], "snd_msg: Wakeups[3] not hit" );
        CYG_TEST_CHECK( prewups[4] + 1 == wakeups[4], "snd_msg: Wakeups[4] not hit" );
        prewups[2] = wakeups[2];
        prewups[3] = wakeups[3];
        prewups[4] = wakeups[4];

        CYG_TEST_PASS( "Tested ISR invoked uITRON functions" );

    } while ( 0 < --loops );

    CYG_TEST_EXIT( "All done" );
    ext_tsk();
}


void body( int n )
{
    unsigned int z;
    ER ercd;
    T_MSG *pk_msg;

    do {
        switch ( intercom ) {
        case NOTHING:
            ercd = slp_tsk();
            CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (doing nothing)" );
            continue;
        case SLP:
            ercd = slp_tsk();
            CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
            wakeups[ n ]++;
            break;
        case SEM:
            ercd = wai_sem( n-1 ); // 1..3 for semas
            CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" );
            wakeups[ n ]++;
            break;
        case FLG:
            ercd = wai_flg( &z, n, (1<<n), TWF_CLR | TWF_ANDW );
            CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" );
            CYG_TEST_CHECK( z & (1<<n), "Flag bit not set" );
            wakeups[ n ]++;
            break;
        case MBX:
            ercd = rcv_msg( &pk_msg, n );
            CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" );
            CYG_TEST_CHECK( pk_msg, "rcv_msg NULL msg" );
            wakeups[ n ]++;
            break;
        case EXIT:
            return;
        }
    } while ( 1 );
}

void task2( unsigned int arg )
{
    ER ercd;
    CYG_TEST_INFO( "Task 2 running" );
    ercd = get_tid( &scratch );
    CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
    CYG_TEST_CHECK( 2 == scratch, "tid not 2" );
    if ( 222 != arg )
        CYG_TEST_FAIL( "Task 2 arg not 222" );
    body(2);
    CYG_TEST_INFO( "Task 2 exiting" );
    ext_tsk();
    CYG_TEST_FAIL( "Task 2 failed to exit" );
}

void task3( unsigned int arg )
{
    ER ercd;
    CYG_TEST_INFO("Task 3 running");
    ercd = get_tid( &scratch );
    CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
    CYG_TEST_CHECK( 3 == scratch, "tid not 3" );
    if ( 333 != arg )
        CYG_TEST_FAIL( "Task 3 arg not 333" );
    body(3);
    CYG_TEST_INFO( "Task 3 exiting" );
    ext_tsk();
    CYG_TEST_FAIL( "Task 3 failed to exit" );
}

void task4( unsigned int arg )
{
    ER ercd;
    CYG_TEST_INFO("Task 4 running");
    ercd = get_tid( &scratch );
    CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
    CYG_TEST_CHECK( 4 == scratch, "tid not 4" );
    if ( 444 != arg )
        CYG_TEST_FAIL( "Task 4 arg not 444" );
    body(4);
    CYG_TEST_INFO( "Task 4 exiting" );
    ext_tsk();
    CYG_TEST_FAIL( "Task 4 failed to exit" );
}

// ------------------------------------------------------------------------
// Start of C++ aware portion, so to speak.
//

#include <cyg/hal/hal_intr.h>
#include <cyg/kernel/intr.hxx>
#include <cyg/kernel/clock.hxx>
#include <cyg/kernel/sched.hxx>
#include <cyg/kernel/sched.inl>

void set_interrupt_number( void )
{
    clock_interrupt = CYGNUM_HAL_INTERRUPT_RTC;
}

// This snippet stolen from kernel/.../clock.cxx to be able to detach
// the RTC from its interrupt source.
class Cyg_RealTimeClock
    : public Cyg_Clock
{
public:
    Cyg_Interrupt       interrupt;

    static cyg_uint32 isr(cyg_vector vector, CYG_ADDRWORD data);

    static void dsr(cyg_vector vector, cyg_ucount32 count, CYG_ADDRWORD data);

    Cyg_RealTimeClock();
};


static Cyg_Interrupt uit_intr(
        (unsigned)CYGNUM_HAL_INTERRUPT_RTC, // Vector to attach to
        0,                              // Queue priority
        (unsigned)0,                    // Data pointer
        &isr_wup_tsk,                   // Interrupt Service Routine
        &cyg_uitron_dsr                 // Deferred Service Routine
);

void
attach_isr( unsigned int (*isr)(unsigned int, unsigned int) )
{
    int inuse;
    int old_ints;
    Cyg_RealTimeClock *prtc = (Cyg_RealTimeClock *)Cyg_Clock::real_time_clock;
    HAL_DISABLE_INTERRUPTS(old_ints);
    HAL_INTERRUPT_MASK( CYGNUM_HAL_INTERRUPT_RTC );
    prtc->interrupt.detach();
#ifndef CYGIMP_KERNEL_INTERRUPTS_CHAIN
    // Only check that the vector was cleared when there's a specific
    // vector for the RTC.  In chain mode, other interrupt handlers
    // may prevent the shared vector from being cleared when detaching
    // the RTC ISR, and this assertion fails.
    HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse );
    CYG_TEST_CHECK( !inuse, "Failed to detach clock ISR" );
#endif
    uit_intr = Cyg_Interrupt( 
        CYGNUM_HAL_INTERRUPT_RTC,       // Vector to attach to
        1,                              // Queue priority
        0,                              // Data pointer
        isr,                            // Interrupt Service Routine
        cyg_uitron_dsr                  // Deferred Service Routine
        );    
    uit_intr.attach();
    HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse );
    CYG_TEST_CHECK( inuse, "Failed to attach new ISR" );
    ACK_CLOCK();
    HAL_INTERRUPT_UNMASK( CYGNUM_HAL_INTERRUPT_RTC );
    HAL_RESTORE_INTERRUPTS(old_ints);
}

void
detach_isr( unsigned int (*isr)(unsigned int, unsigned int) )
{
    int inuse;
    int old_ints;
    Cyg_RealTimeClock *prtc = (Cyg_RealTimeClock *)Cyg_Clock::real_time_clock;
    HAL_DISABLE_INTERRUPTS(old_ints);
    HAL_INTERRUPT_MASK( CYGNUM_HAL_INTERRUPT_RTC );
    uit_intr.detach();
#ifndef CYGIMP_KERNEL_INTERRUPTS_CHAIN
    // See comment above in attach_isr.
    HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse );
    CYG_TEST_CHECK( !inuse, "Failed to detach my ISR" );
#endif
    prtc->interrupt.attach();
    HAL_INTERRUPT_IN_USE( CYGNUM_HAL_INTERRUPT_RTC, inuse );
    CYG_TEST_CHECK( inuse, "Failed to attach clock ISR" );
    ACK_CLOCK();
    HAL_INTERRUPT_UNMASK( CYGNUM_HAL_INTERRUPT_RTC );
    HAL_RESTORE_INTERRUPTS(old_ints);
}


void
lock_sched( void )
{
    cyg_uint32 l;
    Cyg_Scheduler::lock();
    l = Cyg_Scheduler::get_sched_lock();
    CYG_TEST_CHECK( 0 < l, "lock: Sched not locked" );
    CYG_TEST_CHECK( 2 > l, "lock: Sched already locked" );
}

void
unlock_sched( void )
{
    cyg_uint32 l;
    l = Cyg_Scheduler::get_sched_lock();
    CYG_TEST_CHECK( 0 < l, "unlock: Sched not locked" );
    CYG_TEST_CHECK( 2 > l, "unlock: Sched already locked" );
    Cyg_Scheduler::unlock();
}


#else // not enough (or too many) uITRON objects configured in
#define N_A_MSG "not enough uITRON objects to run test"
#endif // not enough (or too many) uITRON objects configured in
#else  // not C++ and some C++ specific options enabled
#define N_A_MSG "C++ specific options selected but this is C"
#endif  // not C++ and some C++ specific options enabled
#else // ! CYGVAR_KERNEL_COUNTERS_CLOCK   - can't test without it
#define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK"
#endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK  - can't test without it
#else  // ! CYGFUN_KERNEL_THREADS_TIMER   - can't test without it
#define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER"
#endif // ! CYGFUN_KERNEL_THREADS_TIMER   - can't test without it
#else  // ! CYGIMP_THREAD_PRIORITY        - can't test without it
#define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE"
#endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE   - can't test without it
#else  // ! CYGPKG_UITRON
#define N_A_MSG "uITRON Compatibility layer disabled"
#endif // CYGPKG_UITRON

#ifdef N_A_MSG
externC void
cyg_start( void )
{
    CYG_TEST_INIT();
    CYG_TEST_NA( N_A_MSG );
}
#endif // N_A_MSG defined ie. we are N/A.

// EOF testintr.c