Subversion Repositories openrisc

/*=================================================================

//

//        slebintr.c

//

//        SPARClite HAL interrupt manipulation test

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later

// version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License

// along with eCos; if not, write to the Free Software Foundation, Inc.,

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

//

// As a special exception, if other files instantiate templates or use

// macros or inline functions from this file, or you compile this file

// and link it with other works to produce a work based on this file,

// this file does not by itself cause the resulting work to be covered by

// the GNU General Public License. However the source code for this file

// must still be made available in accordance with section (3) of the GNU

// General Public License v2.

//

// This exception does not invalidate any other reasons why a work based

// on this file might be covered by the GNU General Public License.

// -------------------------------------------

// ####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):     dsm

// Contributors:    dsm, nickg

// Date:          1998-06-18

//####DESCRIPTIONEND####

*/

#include <pkgconf/system.h>

#include <pkgconf/hal.h>

#include <cyg/infra/cyg_type.h>

#include <cyg/infra/cyg_ass.h>

#include <cyg/infra/testcase.h>

#include <cyg/hal/hal_arch.h>

#include <cyg/hal/hal_intr.h>

#include <cyg/hal/hal_diag.h>

#include <cyg/hal/hal_clock.h>

#include <pkgconf/infra.h>

#include <cyg/infra/diag.h>

#define DELAY(x) \

    CYG_MACRO_START int i; for (i = 0; i < x; i++); CYG_MACRO_END

#define DLA 100

static int l, u, m, j;

int levels[ 16 ];

int    ups[ 16 ];

int  masks[ 16 ];

int   reqs[ 16 ];

#define XDIGIT( q ) (q + ((q < 10) ? '0' : ('A'-10) ))

#define SETSTR( x, y, str ) CYG_MACRO_START \

        str[0] = XDIGIT( x ); \

        str[1] = XDIGIT( y ); \

CYG_MACRO_END

static char lstr[] = "xy Bad level";

static char mstr[] = "xy Bad  mask";

static char ustr[] = "xy Bad    up";

static void checkallbut( int z )

{

    int i;

    for ( i = 1; i < 16; i++ ) {

        int level, up, hipri, mask, req;

        if ( z == i )

            continue;

        SETSTR( i, z, lstr );

        SETSTR( i, z, mstr );

        SETSTR( i, z, ustr );

        HAL_INTERRUPT_QUERY_INFO( i, level, up, hipri, mask, req);

        l = level;

        u = up;

        m = mask;

        j = i;

#if 0 // for manual testing really...

        if ( level != levels[i] )

            CYG_TEST_INFO( lstr );

        if (    up !=    ups[i] )

            CYG_TEST_INFO( ustr );

        if (  mask !=  masks[i] )

            CYG_TEST_INFO( mstr );

        if ( (level != levels[i] )

        |    (   up !=    ups[i] )

        |    ( mask !=  masks[i] ) ) {

            CYG_TEST_INFO( "Re-reading" );

            HAL_INTERRUPT_QUERY_INFO( i, level, up, hipri, mask, req);

        }

#endif

        CYG_TEST_CHECK( level == levels[i], lstr );

        CYG_TEST_CHECK(    up ==    ups[i], ustr );

        CYG_TEST_CHECK(  mask ==  masks[i], mstr );

    }

}

// input is the active phase of the chosen interrupt.  It is assumed that

// the source is normally level-sensititve rather than edge-sensitive.

static void interferewith( int which, int input )

{

    int level, up, hipri, mask, req;

    // Interfere with interrupt 'which'

    HAL_INTERRUPT_CONFIGURE( which, 1, input ); // should be no change

    checkallbut( 0 ); // so don't exclude any of them

    HAL_INTERRUPT_CONFIGURE( which, 1, !input ); // make it other-sensitive

    DELAY( DLA );

    HAL_INTERRUPT_ACKNOWLEDGE( which );

    DELAY( DLA );

    HAL_INTERRUPT_QUERY_INFO( which, level, up, hipri, mask, req);

    CYG_TEST_CHECK( 0 != level , "Int not level-sensitive (-ve level)" );

    if ( input )

        CYG_TEST_CHECK( 0 == up, "Int high level (-ve level)" );

    else

        CYG_TEST_CHECK( 0 != up, "Int low level (-ve level)" );

    CYG_TEST_CHECK( 0 !=  mask , "Int unmasked (-ve level)" );

    CYG_TEST_CHECK( 0 !=   req , "Int not requesting (-ve level)" );

    checkallbut( which ); // don't check #which, we're messing with it

    HAL_INTERRUPT_CONFIGURE( which, 0, input ); // edge, default sense

    DELAY( DLA );

    HAL_INTERRUPT_ACKNOWLEDGE( which );

    DELAY( DLA );

    HAL_INTERRUPT_QUERY_INFO( which, level, up, hipri, mask, req);

    CYG_TEST_CHECK( 0 == level , "Int not edge-sensitive (+ve edge)" );

    if ( input )

        CYG_TEST_CHECK( 0 != up, "Int low edge (+ve edge)" );

    else

        CYG_TEST_CHECK( 0 == up, "Int high edge (+ve edge)" );

    CYG_TEST_CHECK( 0 !=  mask , "Int unmasked (+ve edge)" );

    CYG_TEST_CHECK( 0 ==   req , "Int requesting (+ve edge)" );

    checkallbut( which ); // don't check #which, we're messing with it

    HAL_INTERRUPT_CONFIGURE( which, 0, !input ); // edge, opposite sense

    DELAY( DLA );

    HAL_INTERRUPT_ACKNOWLEDGE( which );

    DELAY( DLA );

    HAL_INTERRUPT_QUERY_INFO( which, level, up, hipri, mask, req);

    CYG_TEST_CHECK( 0 == level , "Int not edge-sensitive (-ve edge)" );

    if ( input )

        CYG_TEST_CHECK( 0 == up, "Int high edge (-ve edge)" );

    else

        CYG_TEST_CHECK( 0 != up, "Int low edge (-ve edge)" );

    CYG_TEST_CHECK( 0 !=  mask , "Int unmasked (-ve edge)" );

    CYG_TEST_CHECK( 0 ==   req , "Int requesting (-ve edge)" );

    checkallbut( which ); // don't check #which, we're messing with it

    HAL_INTERRUPT_CONFIGURE( which, 1, input ); // back to original value

    DELAY( DLA );

    HAL_INTERRUPT_ACKNOWLEDGE( which );

    DELAY( DLA );

    checkallbut( 0 ); // so don't exclude any of them

}

// ------------------------------------------------------------------------

#ifndef CYGPKG_KERNEL

// then the clock is not initialized!

#undef HAL_CLOCK_READ

// so provide a dumb counter, so we do the test a number of times anyway.

static int pseudotime = 0;

#define HAL_CLOCK_READ( _pval_ ) *(_pval_) = \

   ((pseudotime > 10) ? (pseudotime = 0) : ++pseudotime)

#endif

static int start( void )

{

    // We'll mess about with these interrupt sources:

    // 13   : EX_IRQ13 from expansion board, active HIGH

    // 12   : EX_IRQ12 from expansion board, active LOW

    //  4   : EX_IRQ4 from expansion board, active LOW

    //  3   : EX_IRQ3 from expansion board, active HIGH

    int i, hipri;

    for ( i = 1; i < 16; i++ ) {

        HAL_INTERRUPT_QUERY_INFO( i, levels[i], ups[i],

                                  hipri, masks[i], reqs[i]);

    }

    CYG_TEST_CHECK( 0 !=  masks[13], "Int 13 unmasked initially" );

    CYG_TEST_CHECK( 0 !=  masks[12], "Int 12 unmasked initially" );

    CYG_TEST_CHECK( 0 !=  masks[ 4], "Int  4 unmasked initially" );

    CYG_TEST_CHECK( 0 !=  masks[ 3], "Int  3 unmasked initially" );

    CYG_TEST_CHECK( 0 ==   reqs[13], "Int 13 requests initially" );

    CYG_TEST_CHECK( 0 ==   reqs[12], "Int 12 requests initially" );

    CYG_TEST_CHECK( 0 ==   reqs[ 4], "Int  4 requests initially" );

    CYG_TEST_CHECK( 0 ==   reqs[ 3], "Int  3 requests initially" );

    CYG_TEST_CHECK( 0 != levels[13], "Int 13 edgetrig initially" );

    CYG_TEST_CHECK( 0 != levels[12], "Int 12 edgetrig initially" );

    CYG_TEST_CHECK( 0 != levels[ 4], "Int  4 edgetrig initially" );

    CYG_TEST_CHECK( 0 != levels[ 3], "Int  3 edgetrig initially" );

    CYG_TEST_CHECK( 0 !=    ups[13], "Int 13 not up initially" );

    CYG_TEST_CHECK( 0 ==    ups[12], "Int 12 is up initially" );

    CYG_TEST_CHECK( 0 ==    ups[ 4], "Int  4 is up initially" );

    CYG_TEST_CHECK( 0 !=    ups[ 3], "Int  3 not up initially" );

    checkallbut( 0 ); // don't exclude any of them

    // I want to run this loop for 100 centiSeconds, so that 100 clock

    // interrupts have occurred whilst interfering with the other interrupt

    // state, to provoke possible problems with interactions there.  On a

    // 100MHz 86832 with default configuration, this usually gives 1200

    // loops in total, 12 per centiSecond.  But with config variance and

    // caching behaviour, it's quite possible for this loop to take much

    // longer, if it takes over 1/2 a centiSecond, aliasing effects could

    // cause the timing to fail completely, causing test timeouts.  Hence

    // the additional loop limit of 20 times round the inner loop, aiming

    // for a maximum elapsed time of 20 S maximum, plus extra chances to

    // break out part way through the loop if a tick has passed.

    hipri = 0;

    CYG_TEST_INFO( "About to configure interrupts" );

    for ( i = 0; i < 100; i++ ) {

        int t1, t2, j;

        HAL_CLOCK_READ( &t1 );

        // Do this while/until there is a clock tick

        // ie. some interrupt activity:

        for ( j = 0; j < 20; j++ ) {

            t2 = t1;

            hipri++;

            interferewith( 13, 1 );

            interferewith( 3, 1 );

            interferewith( 4, 0 );

            HAL_CLOCK_READ( &t1 );

            if ( t1 < t2 )

                break;                  // clock has wrapped

            t2 = t1;

            interferewith( 12, 0 );

            interferewith( 3, 1 );

            interferewith( 3, 1 );

            HAL_CLOCK_READ( &t1 );

            if ( t1 < t2 )

                break;                  // clock has wrapped

            t2 = t1;

            interferewith( 4, 0 );

            interferewith( 13, 1 );

            interferewith( 12, 0 );

            interferewith( 12, 0 );

            HAL_CLOCK_READ( &t1 );

            if ( t1 < t2 )

                break;                  // clock has wrapped

        }

    }

    CYG_TEST_PASS( "Configured interrupts 3,4,12 & 13 a great deal" );

    return hipri;

}

// -------------------------------------------------------------------------

externC void

#ifdef CYGPKG_KERNEL

cyg_user_start( void )

#else

cyg_start( void )

#endif

{

    int loops;

    CYG_TEST_INIT();

    CYG_TEST_INFO( "cyg_user_start()" );

    HAL_ENABLE_INTERRUPTS();

    loops = start();

    // Typically about 1200 loops execute on the 33MHz 86832;

    // I hoped to put in a check that we hadn't wasted time in

    // spurious interrupts, but kernel instrumentation, for example,

    // is more than enough to slow the world down... so keep this

    // very weak test in, as a placeholder.

    CYG_TEST_CHECK( 100 <= loops, "Not enough tests executed" );

    CYG_TEST_EXIT( "All done" );

}

// -------------------------------------------------------------------------

/* EOF slebintr.c */