OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path
    /openrisc/trunk/rtos/ecos-2.0/packages/io/watchdog/v2_0
    from Rev 27 to Rev 174
    Reverse comparison

Rev 27 → Rev 174

/cdl/watchdog.cdl
0,0 → 1,177
# ====================================================================
#
# watchdog.cdl
#
# eCos watchdog configuration data
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): jskov
# Original data: nickg
# Contributors:
# Date: 1999-07-13
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
cdl_package CYGPKG_IO_WATCHDOG {
display "Watchdog IO device"
define_header watchdog.h
include_dir cyg/io
description "
The watchdog IO device allows applications to make use of a
timer facility. Depending on the underlying hardware device
driver, a watchdog timeout will either cause a board reset
or an action routine to be called. The application must call
the watchdog reset function at regular intervals, or else the
device will timeout. The assumption is that the watchdog timer
should never trigger unless there has been a serious fault in
either the hardware or the software."
 
compile watchdog.cxx
 
cdl_interface CYGINT_WATCHDOG_HW_IMPLEMENTATIONS {
display "Number of watchdog hardware implementations"
no_define
}
 
cdl_interface CYGINT_WATCHDOG_IMPLEMENTATIONS {
display "Number of watchdog implementations"
no_define
requires 1 == CYGINT_WATCHDOG_IMPLEMENTATIONS
}
 
cdl_component CYGPKG_IO_WATCHDOG_IMPLEMENTATION {
display "Watchdog implementation"
flavor none
no_define
description "Implementations of the watchdog device."
 
cdl_option CYGPKG_WATCHDOG_EMULATE {
default_value { 0 == CYGINT_WATCHDOG_HW_IMPLEMENTATIONS }
display "Watchdog emulator"
implements CYGINT_WATCHDOG_IMPLEMENTATIONS
requires CYGVAR_KERNEL_COUNTERS_CLOCK
compile emulate.cxx
description "
When this option is enabled, a watchdog device will be
emulated using the kernel real-time clock."
}
 
cdl_option CYGIMP_WATCHDOG_NONE {
display "No wallclock"
default_value 0
implements CYGINT_WATCHDOG_IMPLEMENTATIONS
description "Disables the watchdog."
}
}
 
cdl_interface CYGINT_WATCHDOG_RESETS_ON_TIMEOUT {
display "Set if device causes a reset on timeout"
no_define
}
 
cdl_option CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT {
display "Set if device causes a reset on timeout"
calculated { CYGINT_WATCHDOG_RESETS_ON_TIMEOUT == 1 }
description "
Some watchdog devices reset the board on timeout - for these
implementations it does not make sense to register timeout
actions so the code gets disabled when this option is set.
When this option is not set, it is the application's
responsibility to register an action handler which can force
a board reset when it gets called."
}
 
cdl_option CYGPKG_IO_WATCHDOG_BUILD_INTERACTIVE_TEST {
display "Build interactive watchdog test"
flavor bool
no_define
default_value 0
description "
This option enables the building of a watchdog test
which can be used to test that the board resets on
watchdog timeout. This test is built separately since
it only makes sense to use interactively."
}
 
cdl_component CYGPKG_IO_WATCHDOG_OPTIONS {
display "Watchdog build options"
flavor none
description "
Package specific build options including control over
compiler flags used only in building this package,
and details of which tests are built."
 
 
cdl_option CYGPKG_IO_WATCHDOG_CFLAGS_ADD {
display "Additional compiler flags"
flavor data
no_define
default_value { "" }
description "
This option modifies the set of compiler flags for
building the watchdog IO device. These flags are used
in addition to the set of global flags."
}
 
cdl_option CYGPKG_IO_WATCHDOG_CFLAGS_REMOVE {
display "Suppressed compiler flags"
flavor data
no_define
default_value { "" }
description "
This option modifies the set of compiler flags for
building the watchdog IO device. These flags are removed from
the set of global flags if present."
}
 
cdl_option CYGPKG_IO_WATCHDOG_TESTS {
display "Watchdog tests"
flavor data
no_define
calculated { CYGPKG_IO_WATCHDOG_BUILD_INTERACTIVE_TEST ?
CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT ? "tests/watchdog2 tests/watchdog_reset" : "tests/watchdog tests/watchdog2 tests/watchdog_reset" :
CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT ? "tests/watchdog2" : "tests/watchdog tests/watchdog2" }
 
description "
This option specifies the set of tests for the
watchdog IO device."
}
}
}
/tests/watchdog.cxx
0,0 → 1,238
//==========================================================================
//
// watchdog.cxx
//
// Watchdog test
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): nickg
// Contributors: nickg
// Date: 1998-07-20
// Description: This test exercises the Watchdog class and checks that it
// works as advertised.
//####DESCRIPTIONEND####
// -------------------------------------------------------------------------
 
#include <pkgconf/kernel.h>
 
#include <cyg/kernel/thread.hxx>
#include <cyg/kernel/thread.inl>
#include <cyg/kernel/sched.hxx>
#include <cyg/kernel/mutex.hxx>
#include <cyg/kernel/sema.hxx>
#include <cyg/kernel/clock.hxx>
 
#include <cyg/kernel/diag.h>
 
#include <cyg/io/watchdog.hxx>
 
#include <cyg/infra/testcase.h>
#include <cyg/infra/diag.h>
 
#if defined(CYGFUN_KERNEL_THREADS_TIMER) && \
defined(CYGVAR_KERNEL_COUNTERS_CLOCK)
 
#include <cyg/kernel/sched.inl>
 
// -------------------------------------------------------------------------
// Data for the test
 
#ifdef CYGNUM_HAL_STACK_SIZE_TYPICAL
#define STACKSIZE CYGNUM_HAL_STACK_SIZE_TYPICAL
#else
#define STACKSIZE (2*1024) // size of thread stack
#endif
 
char thread_stack[STACKSIZE];
 
inline void *operator new(size_t size, void *ptr) { return ptr; };
 
// array of threads.
char thread[sizeof(Cyg_Thread)];
 
Cyg_Thread *th;
 
//cyg_tick_count one_sec;
cyg_tick_count watchdog_delay;
volatile bool watchdog_fired;
volatile cyg_tick_count watchdog_time;
 
#define WATCHDOG_LOOPS_HW 5
#define WATCHDOG_LOOPS_SIM 1
#define WATCHDOG_CYCLES_PER_LOOP_HW 10
#define WATCHDOG_CYCLES_PER_LOOP_SIM 2
#define WATCHDOG_TICKS_TILL_TIMEOUT 10
 
// -------------------------------------------------------------------------
// Action functions:
 
void watchdog_action1( CYG_ADDRWORD data )
{
watchdog_fired = true;
watchdog_time = Cyg_Clock::real_time_clock->current_value();
}
 
void watchdog_action2( CYG_ADDRWORD data )
{
CYG_TEST_PASS_FINISH("Watchdog OK");
}
 
// -------------------------------------------------------------------------
// Thread body
 
 
void watchdog_thread( CYG_ADDRWORD id )
{
cyg_tick_count watchdog_start_time;
cyg_tick_count thread_start_time, thread_end_time;
cyg_ucount8 watchdog_loops, watchdog_cycles_per_loop;
 
if (cyg_test_is_simulator) {
watchdog_loops = WATCHDOG_LOOPS_SIM;
watchdog_cycles_per_loop = WATCHDOG_CYCLES_PER_LOOP_SIM;
} else {
watchdog_loops = WATCHDOG_LOOPS_HW;
watchdog_cycles_per_loop = WATCHDOG_CYCLES_PER_LOOP_HW;
}
 
watchdog_fired = false;
Cyg_Watchdog::watchdog.start();
 
CYG_TEST_INFO("Testing that watchdog does not fire early");
 
for (cyg_ucount8 tries = 0; tries < watchdog_loops; tries++) {
diag_printf("Iteration #%d (testing over %d cycles)\n",
tries, watchdog_cycles_per_loop);
 
// First test that the watchdog does not trigger when being reset.
Cyg_Watchdog_Action wdaction( watchdog_action1, 0 );
 
wdaction.install();
Cyg_Watchdog::watchdog.reset();
 
watchdog_start_time = Cyg_Clock::real_time_clock->current_value();
watchdog_fired = false;
for( cyg_ucount8 i = 0; i < watchdog_cycles_per_loop; i++ ) {
thread_start_time = Cyg_Clock::real_time_clock->current_value();
th->delay( watchdog_delay-2 );
Cyg_Watchdog::watchdog.reset();
if (watchdog_fired) {
thread_end_time = Cyg_Clock::real_time_clock->current_value();
diag_printf("Watchdog fired prematurely after %d ticks\n",
(int)(watchdog_time - watchdog_start_time));
diag_printf(" Thread slept for %d ticks, loop #%d\n",
(int)(thread_end_time - thread_start_time), i);
CYG_TEST_FAIL_FINISH("Watchdog triggered unexpectedly");
break;
} else {
CYG_TEST_STILL_ALIVE(i, "Resetting watchdog...");
Cyg_Watchdog::watchdog.reset();
watchdog_fired = false;
watchdog_start_time = Cyg_Clock::real_time_clock->current_value();
}
}
}
 
// Now check that it triggers when not reset
CYG_TEST_INFO("Testing that watchdog fires");
{
Cyg_Watchdog_Action wdaction( watchdog_action2, 0 );
 
wdaction.install();
Cyg_Watchdog::watchdog.reset();
th->delay( watchdog_delay*WATCHDOG_TICKS_TILL_TIMEOUT );
}
 
CYG_TEST_FAIL_FINISH("Watchdog failed to trigger");
}
 
// -------------------------------------------------------------------------
 
externC void
cyg_start( void )
{
CYG_TEST_INIT();
 
#if !defined(CYGIMP_WATCHDOG_EMULATE) && defined(CYGPKG_HAL_MN10300_STDEVAL1)
// Workaround for PR 17974
if( cyg_test_is_simulator )
CYG_TEST_NA("Watchdog device not implemented in MN10300 simulator.");
#endif
 
 
Cyg_Clock::cyg_resolution res = Cyg_Clock::real_time_clock->get_resolution();
cyg_uint64 wres = Cyg_Watchdog::watchdog.get_resolution();
 
// Calculate how many clock ticks there are in a watchdog cycle.
watchdog_delay = ((cyg_tick_count)wres * (cyg_tick_count)res.divisor );
watchdog_delay /= res.dividend;
th = new((void *)&thread) Cyg_Thread(CYG_SCHED_DEFAULT_INFO,
watchdog_thread,
0,
"watchdog_thread",
(CYG_ADDRESS)thread_stack,
STACKSIZE
);
 
th->resume();
 
// Get the world going
Cyg_Scheduler::scheduler.start();
 
}
 
#else // if defined(CYGFUN_KERNEL_THREADS_TIMER) etc...
 
externC void
cyg_start( void )
{
CYG_TEST_INIT();
CYG_TEST_NA("Kernel real-time clock/threads timer disabled");
}
 
#endif // if defined(CYGFUN_KERNEL_THREADS_TIMER) etc...
 
// -------------------------------------------------------------------------
// EOF watchdog.cxx
/tests/watchdog2.cxx
0,0 → 1,220
//==========================================================================
//
// watchdog2.cxx
//
// Watchdog test
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): nickg
// Contributors: nickg, jskov
// Date: 1998-07-20
// Description: Tests the watchdog driver.
// This test tries to make sure the watchdog does not trigger
// early. On boards where the watchdog performs a reset on
// timeout, there will be no FAIL message - but it should
// PASS even on those boards when the driver implementation
// is correct.
//
//####DESCRIPTIONEND####
// -------------------------------------------------------------------------
 
#include <pkgconf/kernel.h>
 
#include <cyg/kernel/thread.hxx>
#include <cyg/kernel/thread.inl>
#include <cyg/kernel/sched.hxx>
#include <cyg/kernel/mutex.hxx>
#include <cyg/kernel/sema.hxx>
#include <cyg/kernel/clock.hxx>
 
#include <cyg/kernel/diag.h>
 
#include <cyg/io/watchdog.hxx>
 
#include <cyg/infra/testcase.h>
#include <cyg/infra/diag.h>
 
#if defined(CYGFUN_KERNEL_THREADS_TIMER) && \
defined(CYGVAR_KERNEL_COUNTERS_CLOCK)
 
#include <cyg/kernel/sched.inl>
 
// -------------------------------------------------------------------------
// Data for the test
 
#ifdef CYGNUM_HAL_STACK_SIZE_TYPICAL
#define STACKSIZE CYGNUM_HAL_STACK_SIZE_TYPICAL
#else
#define STACKSIZE (2*1024) // size of thread stack
#endif
 
char thread_stack[STACKSIZE];
 
inline void *operator new(size_t size, void *ptr) { return ptr; };
 
// array of threads.
char thread[sizeof(Cyg_Thread)];
 
Cyg_Thread *th;
 
//cyg_tick_count one_sec;
cyg_tick_count watchdog_delay;
volatile bool watchdog_fired;
volatile cyg_tick_count watchdog_time;
 
#define WATCHDOG_CYCLES_PER_LOOP_HW 7
#define WATCHDOG_CYCLES_PER_LOOP_SIM 2
#define WATCHDOG_TICKS_TILL_TIMEOUT 10
 
// -------------------------------------------------------------------------
// Action functions:
 
#ifdef CYGINT_WATCHDOG_RESETS_ON_TIMEOUT
void watchdog_action1( CYG_ADDRWORD data )
{
watchdog_fired = true;
watchdog_time = Cyg_Clock::real_time_clock->current_value();
}
#endif
 
// -------------------------------------------------------------------------
// Thread body
 
void watchdog_thread( CYG_ADDRWORD id )
{
cyg_tick_count watchdog_start_time;
cyg_tick_count thread_start_time, thread_end_time;
cyg_ucount8 watchdog_cycles_per_loop;
 
if (cyg_test_is_simulator) {
watchdog_cycles_per_loop = WATCHDOG_CYCLES_PER_LOOP_SIM;
} else {
watchdog_cycles_per_loop = WATCHDOG_CYCLES_PER_LOOP_HW;
}
 
CYG_TEST_INFO("Testing that watchdog does not fire early");
 
watchdog_fired = false;
Cyg_Watchdog::watchdog.start();
 
#ifdef CYGINT_WATCHDOG_RESETS_ON_TIMEOUT
// First test that the watchdog does not trigger when being reset.
Cyg_Watchdog_Action wdaction( watchdog_action1, 0 );
wdaction.install();
#endif
Cyg_Watchdog::watchdog.reset();
 
watchdog_start_time = Cyg_Clock::real_time_clock->current_value();
watchdog_fired = false;
for( cyg_ucount8 i = 0; i < watchdog_cycles_per_loop; i++ ) {
thread_start_time = Cyg_Clock::real_time_clock->current_value();
th->delay( watchdog_delay-2 );
Cyg_Watchdog::watchdog.reset();
if (watchdog_fired) {
thread_end_time = Cyg_Clock::real_time_clock->current_value();
diag_printf("Watchdog fired prematurely after %d ticks\n",
(int)(watchdog_time - watchdog_start_time));
diag_printf(" Thread slept for %d ticks, loop #%d\n",
(int)(thread_end_time - thread_start_time), i);
CYG_TEST_FAIL_FINISH("Watchdog triggered unexpectedly");
break;
} else {
// No printing - delays are fatal!
// CYG_TEST_STILL_ALIVE(i, "Resetting watchdog...");
Cyg_Watchdog::watchdog.reset();
watchdog_fired = false;
watchdog_start_time = Cyg_Clock::real_time_clock->current_value();
}
}
 
CYG_TEST_PASS_FINISH("Watchdog OK");
}
 
// -------------------------------------------------------------------------
 
externC void
cyg_start( void )
{
CYG_TEST_INIT();
 
#if !defined(CYGIMP_WATCHDOG_EMULATE) && defined(CYGPKG_HAL_MN10300_STDEVAL1)
// Workaround for PR 17974
if( cyg_test_is_simulator )
CYG_TEST_NA("Watchdog device not implemented in MN10300 simulator.");
#endif
 
 
Cyg_Clock::cyg_resolution res = Cyg_Clock::real_time_clock->get_resolution();
cyg_uint64 wres = Cyg_Watchdog::watchdog.get_resolution();
 
// Calculate how many clock ticks there are in a watchdog cycle.
watchdog_delay = ((cyg_tick_count)wres * (cyg_tick_count)res.divisor );
watchdog_delay /= res.dividend;
th = new((void *)&thread) Cyg_Thread(CYG_SCHED_DEFAULT_INFO,
watchdog_thread,
0,
"watchdog_thread",
(CYG_ADDRESS)thread_stack,
STACKSIZE
);
 
th->resume();
 
// Get the world going
Cyg_Scheduler::scheduler.start();
 
}
 
#else // if defined(CYGFUN_KERNEL_THREADS_TIMER) etc...
 
externC void
cyg_start( void )
{
CYG_TEST_INIT();
CYG_TEST_NA("Kernel real-time clock/threads timer disabled");
}
 
#endif // if defined(CYGFUN_KERNEL_THREADS_TIMER) etc...
 
// -------------------------------------------------------------------------
// EOF watchdog.cxx
/tests/watchdog_reset.cxx
0,0 → 1,184
//==========================================================================
//
// watchdog_reset.cxx
//
// Watchdog reset test
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): jskov (based on watchdog.cxx)
// Contributors: jskov, nickg
// Date: 1999-08-27
// Description: Tests that the watchdog timer resets the board.
// This test needs to be run by an operator - automatic
// testing not possible.
//####DESCRIPTIONEND####
// -------------------------------------------------------------------------
 
#include <pkgconf/system.h>
 
#include <cyg/infra/testcase.h>
#include <cyg/infra/diag.h>
 
// Package requirements
#if defined(CYGPKG_KERNEL)
 
#include <pkgconf/kernel.h>
 
// Package option requirements
#if defined(CYGFUN_KERNEL_THREADS_TIMER) && \
defined(CYGVAR_KERNEL_COUNTERS_CLOCK)
 
 
#include <cyg/kernel/thread.inl>
 
#include <cyg/hal/hal_cache.h>
 
#include <cyg/io/watchdog.hxx> // watchdog API
 
 
// -------------------------------------------------------------------------
// Data for the test
 
#ifdef CYGNUM_HAL_STACK_SIZE_TYPICAL
#define STACKSIZE CYGNUM_HAL_STACK_SIZE_TYPICAL
#else
#define STACKSIZE (2*1024) // size of thread stack
#endif
 
char thread_stack[STACKSIZE];
 
inline void *operator new(size_t size, void *ptr) { return ptr; };
 
// array of threads.
char thread[sizeof(Cyg_Thread)];
 
Cyg_Thread *th;
 
//cyg_tick_count one_sec;
cyg_tick_count watchdog_delay;
 
// -------------------------------------------------------------------------
// Thread body
 
volatile int watchdog_accuracy = 50;
 
void watchdog_thread( CYG_ADDRWORD id )
{
diag_printf("Test of watchdog timer accuracy. Expect the test to run\n"
"for at least 10 times the watchdog timeout time. After\n"
"that time you may have to reset the board manually and/or\n"
"restart GDB which tends to get a little confused.\n");
diag_printf("When you get contact with the board again, read the value\n"
"in watchdog_accuracy - it should be close to 100 if the\n"
"watchdog timer is accurate.\n");
// Disable data cache so the variable in memory gets updated.
HAL_DCACHE_SYNC();
HAL_DCACHE_DISABLE();
 
Cyg_Watchdog::watchdog.start();
Cyg_Watchdog::watchdog.reset();
 
while (watchdog_accuracy < 400) {
Cyg_Watchdog::watchdog.reset();
th->delay( watchdog_delay*watchdog_accuracy/100 );
watchdog_accuracy += 5;
}
 
CYG_TEST_FAIL_FINISH("Watchdog failed to reset board. "
"Timer value is off by at least a factor of 4!");
}
 
// -------------------------------------------------------------------------
 
externC void
cyg_start( void )
{
CYG_TEST_INIT();
 
#if !defined(CYGIMP_WATCHDOG_EMULATE) && defined(CYGPKG_HAL_MN10300_STDEVAL1)
// Workaround for PR 17974
if( cyg_test_is_simulator )
CYG_TEST_NA("Watchdog device not implemented in MN10300 simulator.");
#endif
 
 
Cyg_Clock::cyg_resolution res = Cyg_Clock::real_time_clock->get_resolution();
cyg_uint64 wres = Cyg_Watchdog::watchdog.get_resolution();
 
// Calculate how many clock ticks there are in a watchdog cycle.
watchdog_delay = ((cyg_tick_count)wres * (cyg_tick_count)res.divisor );
watchdog_delay /= res.dividend;
th = new((void *)&thread) Cyg_Thread(CYG_SCHED_DEFAULT_INFO,
watchdog_thread,
0,
"watchdog_thread",
(CYG_ADDRESS)thread_stack,
STACKSIZE
);
 
th->resume();
 
// Get the world going
Cyg_Scheduler::scheduler.start();
 
}
 
#else // CYGFUN_KERNEL_THREADS_TIMER etc...
#define N_A_MSG "Needs kernel RTC/threads timer"
#endif
 
#else // CYGPKG_KERNEL
#define N_A_MSG "Needs Kernel"
#endif
 
#ifdef N_A_MSG
void
cyg_start( void )
{
CYG_TEST_INIT();
CYG_TEST_NA( N_A_MSG);
}
#endif // N_A_MSG
 
// -------------------------------------------------------------------------
// EOF watchdog_reset.cxx
/include/watchdog.hxx
0,0 → 1,168
#ifndef CYGONCE_DEVS_WATCHDOG_HXX
#define CYGONCE_DEVS_WATCHDOG_HXX
 
//==========================================================================
//
// watchdog.hxx
//
// Watchdog interface declaration
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): nickg
// Contributors: nickg
// Date: 1998-07-14
// Purpose: Watchdog declarations
// Description: This file defines the interface to the watchdog device
// that provides timer based recovery from software and
// hardware faults.
// Usage: #include <cyg/devs/watchdog.hxx>
//
//####DESCRIPTIONEND####
//
//==========================================================================
 
#include <cyg/kernel/ktypes.h>
#include <cyg/infra/cyg_ass.h> // assertion macros
 
class Cyg_Watchdog_Action;
 
// -------------------------------------------------------------------------
// Watchdog class
 
class Cyg_Watchdog
{
 
Cyg_Watchdog_Action *action_list;
 
cyg_uint64 resolution;
public:
 
Cyg_Watchdog();
 
// Return time interval allowed between resets before watchdog
// triggers, in nanoseconds.
cyg_uint64 get_resolution( void );
// Start the watchdog running.
void start( void );
 
// Reset watchdog timer. This needs to be called regularly to prevent
// the watchdog firing.
void reset( void );
 
#ifndef CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT
// Trigger the watchdog as if the timer had expired.
void trigger( void );
 
// Register an action routine that will be called when the timer
// triggers.
void install_action( Cyg_Watchdog_Action *wdaction );
 
// Deregister a previously registered action routine.
void uninstall_action( Cyg_Watchdog_Action *wdaction );
#endif
// A static instance of the single system defined watchdog device.
static Cyg_Watchdog watchdog;
 
private:
void init_hw( void );
};
 
#ifndef CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT
// -------------------------------------------------------------------------
// Watchdog action class
 
class Cyg_Watchdog_Action
{
friend class Cyg_Watchdog;
 
Cyg_Watchdog_Action *next; // link in chain
void (*action)( CYG_ADDRWORD data ); // action function
 
CYG_ADDRWORD data; // data argument
public:
 
Cyg_Watchdog_Action(
void (*action)( CYG_ADDRWORD data ),
CYG_ADDRWORD data
);
 
~Cyg_Watchdog_Action();
 
void install();
void uninstall();
};
 
// -------------------------------------------------------------------------
// Cyg_Watchdog_Action inlines
 
inline Cyg_Watchdog_Action::Cyg_Watchdog_Action(
void (*action_arg)( CYG_ADDRWORD data ),
CYG_ADDRWORD data_arg
)
{
next = NULL;
action = action_arg;
data = data_arg;
}
 
inline Cyg_Watchdog_Action::~Cyg_Watchdog_Action()
{
Cyg_Watchdog::watchdog.uninstall_action( this );
}
 
inline void Cyg_Watchdog_Action::install()
{
Cyg_Watchdog::watchdog.install_action( this );
}
 
inline void Cyg_Watchdog_Action::uninstall()
{
Cyg_Watchdog::watchdog.uninstall_action( this );
}
 
#endif // CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT
 
// -------------------------------------------------------------------------
#endif // ifndef CYGONCE_DEVS_WATCHDOG_HXX
// EOF watchdog.hxx
/ChangeLog
0,0 → 1,293
2000-05-31 Jesper Skov <jskov@redhat.com>
 
* tests/watchdog.cxx: fix comment.
 
* tests/watchdog2.cxx:
* cdl/watchdog.cdl:
watchdog2 tests timeout is not too fast (safe for both types of
watchdog semantics).
* tests/watchdog_reset.cxx:
* src/emulate.cxx:
* include/watchdog.hxx:
Fixed compile errors.
 
* cdl/watchdog.cdl: Only build test if the watchdog does not reset
the board.
Added build option for interactive reset test.
 
2000-05-30 Jesper Skov <jskov@redhat.com>
 
* tests/watchdog_reset.cxx:
* tests/watchdog.cxx:
* src/emulate.cxx:
* src/watchdog.cxx:
* include/watchdog.hxx:
* cdl/watchdog.cdl:
Moved to io/watchdog.
 
2000-01-31 Simon FitzMaurice <sdf@cygnus.co.uk>
* cdl/watchdog.cdl:
 
Adjust help URLs in line with new doc layout.
 
2000-01-28 Simon FitzMaurice <sdf@cygnus.co.uk>
* cdl/watchdog.cdl:
 
Adjust help URLs in line with new doc layout.
 
2000-01-19 Hugo Tyson <hmt@cygnus.co.uk>
 
* cdl/*.cdl: Add descriptions to a number of options &c which were
lacking same, also tidied up other typos as noticed en passant.
 
1999-11-03 John Dallaway <jld@cygnus.co.uk>
 
* cdl/watchdog.cdl: Define build options.
 
1999-09-09 Jonathan Larmour <jlarmour@cygnus.co.uk>
 
* include/pkgconf/watchdog.h: Rename CYGPKG_HAL_MN10300_SIM to
CYGPKG_HAL_MN10300_AM31_SIM
 
1999-09-07 Jesper Skov <jskov@cygnus.co.uk>
 
* include/pkgconf/watchdog.h:
* src/aeb1.cxx: [added]
* src/PKGconf.mak:
* tests/PKGconf.mak:
Added watchdog driver for AEB-1 board.
 
1999-09-07 Jesper Skov <jskov@cygnus.co.uk>
PRs 20427, 20428, 20432
* tests/PKGconf.mak (TESTS): Clear on targets that reset the
board.
 
1999-09-01 Jesper Skov <jskov@cygnus.co.uk>
* cdl/watchdog.cdl:
* include/pkgconf/watchdog.h:
* src/PKGconf.mak:
* src/sh.cxx:
Added watchdog driver for SH.
 
1999-08-27 Jesper Skov <jskov@cygnus.co.uk>
* include/pkgconf/watchdog.h:
* src/PKGconf.mak:
* src/ebsa285.cxx:
Added watchdog device for 21285.
 
* tests/watchdog_reset.cxx:
* tests/PKGconf.mak (TESTS):
Added test for watchdog devices that reset the board.
 
1999-08-24 Nick Garnett <nickg@cygnus.co.uk>
 
* src/mn10300.cxx: Turn watchdog off in Cyg_Watchdog::trigger() to
prevent it repeating.
 
1999-08-18 Nick Garnett <nickg@cygnus.co.uk>
 
* include/pkgconf/watchdog.h: Made test for use of a non-emulated
watchdog more generic for MN10300 targets.
 
* src/emulate.cxx:
* include/watchdog.hxx (class Cyg_Watchdog):
Added get_resolution() to return maximum time, in nanoseconds,
between calls to reset().
 
* tests/watchdog.cxx:
Modified to use the value returned from get_resolution() to
control the timing of reset() calls.
* src/mn10300.cxx:
Added support for AM33 variant. Since the AM33 can only provide a
maximum watchdog cycle time of 621ms, this has motiviated the
addition of the get_resolution() call described above.
 
1999-07-14 Jesper Skov <jskov@cygnus.co.uk>
 
* src/mn10300.cxx:
* src/emulate.cxx:
Include pkgconf/kernel.h.
 
1999-04-21 Gary Thomas <gthomas@cygnus.co.uk>
 
* tests/watchdog.cxx: The 'keep alive' message was interfering
with the watchdog measurement. Some rearrangement fixes this.
 
1999-04-20 Jonathan Larmour <jlarmour@cygnus.co.uk>
 
* tests/watchdog.cxx:
Restrict number of loops, and number of seconds per loop when we
detect we are in a simulator. Do this instead of changing the
value of one_sec in the simulator, since this invalidates the test
somewhat.
Output occasional messages to reassure the user that the test is
still running.
Fix for PR 19865
 
1999-04-14 Jesper Skov <jskov@cygnus.co.uk>
 
* tests/watchdog.cxx (cyg_start): Added workaround for PR 17974.
 
1999-04-12 John Dallaway <jld@cygnus.co.uk>
 
* include/pkgconf/watchdog.h: Add cdl_package doc attribute.
 
1999-04-08 Gary Thomas <gthomas@cygnus.co.uk>
 
* tests/watchdog.cxx: PR 19773 - Loop over first test for better
coverage. Print some additional messages, especially if failure
detected. Reset watchdog after installing handler.
(watchdog_thread): Capture fail time before printing message.
 
1999-04-07 Jesper Skov <jskov@cygnus.co.uk>
PR 19667
* tests/watchdog.cxx (cyg_start):
Changed to use the new Cyg_Thread constructor.
 
1999-03-22 Hugo Tyson <hmt@cygnus.co.uk>
 
* tests/watchdog.cxx:
Use CYGNUM_HAL_STACK_SIZE_TYPICAL for the stack size instead of
CYGNUM_HAL_MINIMUM_STACK_SIZE.
 
1999-03-12 Hugo Tyson <hmt@cygnus.co.uk>
 
* tests/watchdog.cxx:
Deal with CYGNUM_HAL_MINIMUM_STACK_SIZE requirement.
 
1999-03-04 Gary Thomas <gthomas@cygnus.co.uk>
 
* include/pkgconf/watchdog.h: Make package stand-alone (no "DEVICES")
 
1999-02-20 Jonathan Larmour <jlarmour@cygnus.co.uk>
 
* src/mn10300.cxx:
Change CYG_VECTOR_WATCHDOG to CYGNUM_HAL_INTERRUPT_WATCHDOG in line
with HAL changes.
General QA improvements
 
1999-02-03 Jesper Skov <jskov@cygnus.co.uk>
PR 19034
* tests/watchdog.cxx: Reduced run-time on SIM.
 
1998-12-17 Jesper Skov <jskov@cygnus.co.uk>
 
* tests/watchdog.cxx: Do NOP test if kernel RTC disabled.
 
1998-10-23 Jesper Skov <jskov@cygnus.co.uk>
 
* tests/watchdog.cxx (cyg_start): Reduce test time on TX39 SIM.
 
* include/pkgconf/watchdog.h: Use emulatation code for MN10300
SIM.
 
Tue Oct 20 15:52:46 1998 Jonathan Larmour <jlarmour@cygnus.co.uk>
 
* src/mn10300.cxx:
Include <pkgconf/watchdog.h> so that we get CYGIMP_WATCHDOG_EMULATE
defined appropriately
 
* src/PKGconf.mak:
Remove unnecessary override of PKGCONF_CXXFLAGS
 
1998-09-26 Bart Veer <bartv@cygnus.co.uk>
 
* include/pkgconf/watchdog.h:
PR17501: When using the emulation there is a requirement on the
kernel clock. This has been added to the configuration data. The
mn10300 hardware implementation does not have this requirement,
but there is no easy way to express this at present.
 
1998-09-12 Bart Veer <bartv@cygnus.co.uk>
 
* include/pkgconf/watchdog.h:
Added missing descriptions (PR 17184)
 
1998-09-02 Bart Veer <bartv@cygnus.co.uk>
 
* include/pkgconf/watchdog.h:
Added minimal configuration data.
 
1998-09-01 Nick Garnett <nickg@cygnus.co.uk>
 
* src/mn10300.cxx:
Added include for <cyg/kernel/sched.inl>, for scheduler lock and
unlock functions.
 
* src/PKGconf.mak:
Added mn10300.cxx to COMPILE for mn10300.
 
* include/pkgconf/watchdog.h:
Default to using real hardware on MN10300.
 
Fri Aug 28 09:42:26 1998 Jonathan Larmour <jlarmour@cygnus.co.uk>
 
* tests/watchdog.cxx:
Rename int main(argc, argv) to void cyg_start( void ) under the
new entry point system. Therefore also remove return code.
 
Tue Aug 18 16:51:24 1998 Jonathan Larmour <jlarmour@cygnus.co.uk>
 
* tests/watchdog.cxx:
Move inclusion of thread.inl to before sched.hxx to prevent inline
warnings
 
1998-08-14 Nick Garnett <nickg@cygnus.co.uk>
 
* src/emulate.cxx:
Added include for cyg/kernel/sched.inl.
 
1998-07-31 Nick Garnett <nickg@cygnus.co.uk>
 
* src/PKGconf.mak:
Added mn10300.cxx to COMPILE list.
 
* src/mn10300.cxx:
Completed implementation using MN10300 watchdog timer.
 
* include/watchdog.hxx:
Renamed 'register' functions to 'install'. Added install() and
uninstall() to Cyg_Watchdog_Action class.
 
* include/pkgconf/watchdog.h:
Added this file to contain watchdog config options.
 
1998-07-29 Nick Garnett <nickg@cygnus.co.uk>
 
* include/watchdog.hxx, src/emulate.cxx:
Created initial versions of watchdog device.
 
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
/src/watchdog.cxx
0,0 → 1,172
//==========================================================================
//
// io/watchdog/watchdog.cxx
//
// Watchdog common code
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): nickg
// Contributors: nickg
// Date: 1999-02-18
// Purpose: Watchdog class implementation
//
//####DESCRIPTIONEND####
//
//==========================================================================
 
#include <pkgconf/system.h> // system configuration file
#include <pkgconf/watchdog.h> // configuration for this package
 
#include <cyg/infra/cyg_trac.h> // tracing macros
#include <cyg/infra/cyg_ass.h> // assertion macros
 
#include <cyg/hal/drv_api.h> // for locking
 
#include <cyg/io/watchdog.hxx> // watchdog API
 
// -------------------------------------------------------------------------
// Statics
 
// A static pointer to the single system defined watchdog device.
Cyg_Watchdog Cyg_Watchdog::watchdog;
 
// -------------------------------------------------------------------------
// Constructor
 
 
Cyg_Watchdog::Cyg_Watchdog()
{
CYG_REPORT_FUNCTION();
 
#ifndef CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT
action_list = 0;
#endif
 
// HW driver initialization. This must set the watchdog resolution.
init_hw();
CYG_REPORT_RETURN();
}
 
// -------------------------------------------------------------------------
// Return reset resolution
 
cyg_uint64
Cyg_Watchdog::get_resolution()
{
return resolution;
}
 
#ifndef CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT
// -------------------------------------------------------------------------
// Trigger the watchdog as if the timer had expired. This should be called
// from the driver's ISR.
 
void
Cyg_Watchdog::trigger()
{
CYG_REPORT_FUNCTION();
cyg_drv_dsr_lock();
Cyg_Watchdog_Action *act = action_list;
 
while( 0 != act )
{
act->action( act->data );
 
act = act->next;
}
 
cyg_drv_dsr_unlock();
 
CYG_REPORT_RETURN();
}
// -------------------------------------------------------------------------
// Register an action routine that will be called when the timer
// triggers.
 
void
Cyg_Watchdog::install_action( Cyg_Watchdog_Action *action )
{
CYG_REPORT_FUNCTION();
cyg_drv_dsr_lock();
action->next = action_list;
action_list = action;
 
cyg_drv_dsr_unlock();
 
CYG_REPORT_RETURN();
}
 
// -------------------------------------------------------------------------
// Deregister a previously registered action routine.
 
void
Cyg_Watchdog::uninstall_action( Cyg_Watchdog_Action *action )
{
CYG_REPORT_FUNCTION();
cyg_drv_dsr_lock();
 
Cyg_Watchdog_Action **act_ptr = &action_list;
 
while( 0 != *act_ptr )
{
Cyg_Watchdog_Action *a = *act_ptr;
 
if( a == action )
{
*act_ptr = a->next;
break;
}
act_ptr = &a->next;
}
cyg_drv_dsr_unlock();
 
CYG_REPORT_RETURN();
}
 
#endif // CYGSEM_WATCHDOG_RESETS_ON_TIMEOUT
 
// -------------------------------------------------------------------------
// EOF io/watchdog/watchdog.cxx
/src/emulate.cxx
0,0 → 1,149
//==========================================================================
//
// io/watchdog/emulate.cxx
//
// Watchdog implementation emulation
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): nickg
// Contributors: nickg
// Date: 1998-07-29
// Purpose: Watchdog class implementation
// Description: Contains an implementation of the Watchdog class for use
// when there is no hardware watchdog timer. Instead it is
// emulated using an Alarm object.
//
//####DESCRIPTIONEND####
//
//==========================================================================
 
#include <pkgconf/watchdog.h> // watchdog configuration file
#include <pkgconf/kernel.h> // Kernel config
 
#include <cyg/kernel/ktypes.h> // base kernel types
#include <cyg/infra/cyg_trac.h> // tracing macros
#include <cyg/infra/cyg_ass.h> // assertion macros
#include <cyg/kernel/instrmnt.h> // instrumentation
 
#include <cyg/kernel/clock.hxx> // clock and alarm
#include <cyg/kernel/sched.hxx> // scheduler
 
#include <cyg/io/watchdog.hxx> // watchdog API
 
#include <cyg/kernel/sched.inl> // scheduler inlines
 
// -------------------------------------------------------------------------
// Forward definitions
 
static cyg_alarm_fn watchdog_alarm;
 
// -------------------------------------------------------------------------
// Statics
 
static Cyg_Alarm alarm( Cyg_Clock::real_time_clock, watchdog_alarm, 0 );
 
// One second's worth of ticks.
static cyg_tick_count one_sec;
 
// -------------------------------------------------------------------------
// HW init
 
void
Cyg_Watchdog::init_hw(void)
{
CYG_REPORT_FUNCTION();
 
Cyg_Clock::cyg_resolution res = Cyg_Clock::real_time_clock->get_resolution();
 
one_sec = ( res.divisor * 1000000000LL ) / res.dividend ;
 
resolution = 1000000000LL;
 
CYG_REPORT_RETURN();
}
 
// -------------------------------------------------------------------------
// Start the watchdog running.
 
void Cyg_Watchdog::start()
{
CYG_REPORT_FUNCTION();
Cyg_Clock::cyg_resolution res = Cyg_Clock::real_time_clock->get_resolution();
 
// Set alarm to a one second single-shot trigger
alarm.initialize( Cyg_Clock::real_time_clock->current_value() + one_sec, 0 );
 
CYG_REPORT_RETURN();
}
 
// -------------------------------------------------------------------------
// Reset watchdog timer. This needs to be called regularly to prevent
// the watchdog firing.
 
void Cyg_Watchdog::reset()
{
CYG_REPORT_FUNCTION();
Cyg_Clock::cyg_resolution res = Cyg_Clock::real_time_clock->get_resolution();
 
Cyg_Scheduler::lock();
// Set alarm to a one second single-shot trigger
alarm.initialize( Cyg_Clock::real_time_clock->current_value() + one_sec, 0 );
 
Cyg_Scheduler::unlock();
 
CYG_REPORT_RETURN();
}
 
// -------------------------------------------------------------------------
// Alarm function
 
void watchdog_alarm( Cyg_Alarm *a, CYG_ADDRWORD data)
{
CYG_REPORT_FUNCTION();
// Disable alarm just in case
alarm.disable();
 
Cyg_Watchdog::watchdog.trigger();
}
 
// -------------------------------------------------------------------------
// EOF watchdog/emulate.cxx

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.