watchdogimpl.h

Go to the documentation of this file.

/*
 *  COPYRIGHT (c) 1989-2004.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.org/license/LICENSE.
 */

#ifndef _RTEMS_SCORE_WATCHDOGIMPL_H
#define _RTEMS_SCORE_WATCHDOGIMPL_H

#include <rtems/score/watchdog.h>
#include <rtems/score/assert.h>
#include <rtems/score/chainimpl.h>
#include <rtems/score/isrlock.h>

#ifdef __cplusplus
extern "C" {
#endif

#define WATCHDOG_INITIALIZER( routine, id, user_data ) \
  { \
    { NULL, NULL }, \
    WATCHDOG_INACTIVE, \
    0, 0, 0, 0, \
    ( routine ), ( id ), ( user_data ) \
  }

typedef struct {
  Chain_Node Node;

  Watchdog_Interval delta_interval;

  Chain_Node *current;
} Watchdog_Iterator;

typedef struct {
  ISR_LOCK_MEMBER( Lock )

  
  Chain_Control Watchdogs;

  Chain_Control Iterators;
} Watchdog_Header;

SCORE_EXTERN Watchdog_Header _Watchdog_Ticks_header;

SCORE_EXTERN Watchdog_Header _Watchdog_Seconds_header;

RTEMS_INLINE_ROUTINE void _Watchdog_Acquire(
  Watchdog_Header  *header,
  ISR_lock_Context *lock_context
)
{
  _ISR_lock_ISR_disable_and_acquire( &header->Lock, lock_context );
}

RTEMS_INLINE_ROUTINE void _Watchdog_Release(
  Watchdog_Header  *header,
  ISR_lock_Context *lock_context
)
{
  _ISR_lock_Release_and_ISR_enable( &header->Lock, lock_context );
}

RTEMS_INLINE_ROUTINE void _Watchdog_Flash(
  Watchdog_Header  *header,
  ISR_lock_Context *lock_context
)
{
  _ISR_lock_Flash( &header->Lock, lock_context );
}

void _Watchdog_Handler_initialization( void );

void _Watchdog_Tick( void );

Watchdog_States _Watchdog_Remove (
  Watchdog_Header  *header,
  Watchdog_Control *the_watchdog
);

void _Watchdog_Adjust_backward(
  Watchdog_Header   *header,
  Watchdog_Interval  units
);

void _Watchdog_Adjust_backward_locked(
  Watchdog_Header   *header,
  Watchdog_Interval  units
);

void _Watchdog_Adjust_forward(
  Watchdog_Header   *header,
  Watchdog_Interval  units
);

void _Watchdog_Adjust_forward_locked(
  Watchdog_Header   *header,
  Watchdog_Interval  units,
  ISR_lock_Context  *lock_context
);

void _Watchdog_Insert (
  Watchdog_Header  *header,
  Watchdog_Control *the_watchdog
);

void _Watchdog_Insert_locked(
  Watchdog_Header  *header,
  Watchdog_Control *the_watchdog,
  ISR_lock_Context *lock_context
);

void _Watchdog_Tickle (
  Watchdog_Header *header
);

RTEMS_INLINE_ROUTINE void _Watchdog_Preinitialize(
  Watchdog_Control *the_watchdog
)
{
  the_watchdog->state = WATCHDOG_INACTIVE;
#if defined(RTEMS_DEBUG)
  the_watchdog->routine = NULL;
  the_watchdog->id = 0;
  the_watchdog->user_data = NULL;
#endif
}

RTEMS_INLINE_ROUTINE void _Watchdog_Initialize(
  Watchdog_Control               *the_watchdog,
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  _Assert( the_watchdog->state == WATCHDOG_INACTIVE );
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
}

RTEMS_INLINE_ROUTINE bool _Watchdog_Is_active(
  Watchdog_Control *the_watchdog
)
{

  return ( the_watchdog->state == WATCHDOG_ACTIVE );

}

RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_ACTIVE;

}

RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{

  _Watchdog_Tickle( &_Watchdog_Ticks_header );

}

RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{

  _Watchdog_Tickle( &_Watchdog_Seconds_header );

}

RTEMS_INLINE_ROUTINE void _Watchdog_Insert_ticks(
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_header, the_watchdog );

}

RTEMS_INLINE_ROUTINE void _Watchdog_Insert_seconds(
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Seconds_header, the_watchdog );

}

RTEMS_INLINE_ROUTINE Watchdog_States _Watchdog_Remove_ticks(
  Watchdog_Control *the_watchdog
)
{
  return _Watchdog_Remove( &_Watchdog_Ticks_header, the_watchdog );
}

RTEMS_INLINE_ROUTINE Watchdog_States _Watchdog_Remove_seconds(
  Watchdog_Control *the_watchdog
)
{
  return _Watchdog_Remove( &_Watchdog_Seconds_header, the_watchdog );
}

RTEMS_INLINE_ROUTINE void _Watchdog_Reset_ticks(
  Watchdog_Control *the_watchdog
)
{

  _Watchdog_Remove_ticks( the_watchdog );

  _Watchdog_Insert( &_Watchdog_Ticks_header, the_watchdog );

}

RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
  Watchdog_Control *the_watchdog
)
{

  return ( (Watchdog_Control *) the_watchdog->Node.next );

}

RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Previous(
  Watchdog_Control *the_watchdog
)
{

  return ( (Watchdog_Control *) the_watchdog->Node.previous );

}

RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
  Watchdog_Header *header
)
{

  return ( (Watchdog_Control *) _Chain_First( &header->Watchdogs ) );

}

RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Last(
  Watchdog_Header *header
)
{

  return ( (Watchdog_Control *) _Chain_Last( &header->Watchdogs ) );

}

RTEMS_INLINE_ROUTINE bool _Watchdog_Is_empty(
  const Watchdog_Header *header
)
{
  return _Chain_Is_empty( &header->Watchdogs );
}

RTEMS_INLINE_ROUTINE void _Watchdog_Header_initialize(
  Watchdog_Header *header
)
{
  _ISR_lock_Initialize( &header->Lock, "Watchdog" );
  _Chain_Initialize_empty( &header->Watchdogs );
  _Chain_Initialize_empty( &header->Iterators );
}

#ifdef __cplusplus
}
#endif

#endif
/* end of include file */