Changeset 76ac1ee in rtems


Ignore:
Timestamp:
Dec 23, 2015, 6:29:47 AM (22 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
master
Children:
2e8c4ad
Parents:
2b9374e1
git-author:
Sebastian Huber <sebastian.huber@…> (12/23/15 06:29:47)
git-committer:
Sebastian Huber <sebastian.huber@…> (01/19/16 07:36:14)
Message:

score: Fix simple timecounter support

Update #2502.

Files:
17 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/arm/shared/armv7m/clock/armv7m-clock-config.c

    r2b9374e1 r76ac1ee  
    2424static void Clock_isr(void *arg);
    2525
    26 static rtems_timecounter_simple _ARMV7M_TC;
     26typedef struct {
     27  rtems_timecounter_simple base;
     28  bool countflag;
     29} ARMV7M_Timecounter;
     30
     31static ARMV7M_Timecounter _ARMV7M_TC;
    2732
    2833static uint32_t _ARMV7M_TC_get(rtems_timecounter_simple *tc)
     
    3338}
    3439
    35 static bool _ARMV7M_TC_is_pending(rtems_timecounter_simple *tc)
     40static bool _ARMV7M_TC_is_pending(rtems_timecounter_simple *base)
    3641{
    37   volatile ARMV7M_SCB *scb = _ARMV7M_SCB;
     42  ARMV7M_Timecounter *tc = (ARMV7M_Timecounter *) base;
     43  rtems_interrupt_level level;
     44  bool countflag;
    3845
    39   return ((scb->icsr & ARMV7M_SCB_ICSR_PENDSTSET) != 0);
     46  rtems_interrupt_disable(level);
     47
     48  countflag = tc->countflag;
     49  if (!countflag) {
     50    volatile ARMV7M_Systick *systick = _ARMV7M_Systick;
     51
     52    countflag = ((systick->csr & ARMV7M_SYSTICK_CSR_COUNTFLAG) != 0);
     53    tc->countflag = countflag;
     54  }
     55
     56  rtems_interrupt_enable(level);
     57
     58  return countflag;
    4059}
    4160
     
    4968}
    5069
    51 static void _ARMV7M_TC_tick(void)
     70static void _ARMV7M_TC_at_tick(rtems_timecounter_simple *base)
    5271{
    53   rtems_timecounter_simple_downcounter_tick(&_ARMV7M_TC, _ARMV7M_TC_get);
    54 }
     72  ARMV7M_Timecounter *tc = (ARMV7M_Timecounter *) base;
     73  volatile ARMV7M_Systick *systick = _ARMV7M_Systick;
    5574
    56 static void _ARMV7M_Systick_at_tick(void)
    57 {
    58   volatile ARMV7M_Systick *systick = _ARMV7M_Systick;
     75  tc->countflag = false;
    5976
    6077  /* Clear COUNTFLAG */
    6178  systick->csr;
     79}
     80
     81static void _ARMV7M_TC_tick(void)
     82{
     83  rtems_timecounter_simple_downcounter_tick(
     84    &_ARMV7M_TC.base,
     85    _ARMV7M_TC_get,
     86    _ARMV7M_TC_at_tick
     87  );
    6288}
    6389
     
    96122
    97123  rtems_timecounter_simple_install(
    98     &_ARMV7M_TC,
     124    &_ARMV7M_TC.base,
    99125    freq,
    100126    interval,
     
    111137
    112138#define Clock_driver_timecounter_tick() _ARMV7M_TC_tick()
    113 
    114 #define Clock_driver_support_at_tick() \
    115   _ARMV7M_Systick_at_tick()
    116139
    117140#define Clock_driver_support_initialize_hardware() \
  • c/src/lib/libbsp/m68k/mcf52235/clock/clock.c

    r2b9374e1 r76ac1ee  
    3333}
    3434
     35static void mcf52235_tc_at_tick(rtems_timecounter_simple *tc)
     36{
     37  MCF_PIT1_PCSR |= MCF_PIT_PCSR_PIF;
     38}
     39
    3540static void mcf52235_tc_tick(void)
    3641{
    37   rtems_timecounter_simple_downcounter_tick(&mcf52235_tc, mcf52235_tc_get);
     42  rtems_timecounter_simple_downcounter_tick(
     43    &mcf52235_tc,
     44    mcf52235_tc_get,
     45    mcf52235_tc_at_tick
     46  );
    3847}
    39 
    40 /*
    41  * Periodic interval timer interrupt handler
    42  */
    43 #define Clock_driver_support_at_tick()             \
    44     do {                                           \
    45         MCF_PIT1_PCSR |= MCF_PIT_PCSR_PIF;         \
    46     } while (0)                                    \
    4748
    4849/*
  • c/src/lib/libbsp/m68k/mcf5225x/clock/clock.c

    r2b9374e1 r76ac1ee  
    3333}
    3434
     35static void mcf5225x_tc_at_tick(rtems_timecounter_simple *tc)
     36{
     37  MCF_PIT1_PCSR |= MCF_PIT_PCSR_PIF;
     38}
     39
    3540static void mcf5225x_tc_tick(void)
    3641{
    37   rtems_timecounter_simple_downcounter_tick(&mcf5225x_tc, mcf5225x_tc_get);
     42  rtems_timecounter_simple_downcounter_tick(
     43    &mcf5225x_tc,
     44    mcf5225x_tc_get,
     45    mcf5225x_tc_at_tick
     46  );
    3847}
    39 
    40 /*
    41  * Periodic interval timer interrupt handler
    42  */
    43 #define Clock_driver_support_at_tick()             \
    44     do {                                           \
    45         MCF_PIT1_PCSR |= MCF_PIT_PCSR_PIF;         \
    46     } while (0)                                    \
    4748
    4849/*
  • c/src/lib/libbsp/m68k/mcf5329/clock/clock.c

    r2b9374e1 r76ac1ee  
    3333}
    3434
     35static void mcf5329_tc_at_tick(rtems_timecounter_simple *tc)
     36{
     37  MCF_PIT3_PCSR |= MCF_PIT_PCSR_PIF;
     38}
     39
    3540static void mcf5329_tc_tick(void)
    3641{
    37   rtems_timecounter_simple_downcounter_tick(&mcf5329_tc, mcf5329_tc_get);
     42  rtems_timecounter_simple_downcounter_tick(
     43    &mcf5329_tc,
     44    mcf5329_tc_get,
     45    mcf5329_tc_at_tick
     46  );
    3847}
    39 
    40 /*
    41  * Periodic interval timer interrupt handler
    42  */
    43 #define Clock_driver_support_at_tick()             \
    44     do {                                           \
    45         MCF_PIT3_PCSR |= MCF_PIT_PCSR_PIF;         \
    46     } while (0)                                    \
    4748
    4849/*
  • c/src/lib/libbsp/m68k/uC5282/clock/clock.c

    r2b9374e1 r76ac1ee  
    1616#include <bsp.h>
    1717#include <mcf5282/mcf5282.h>
     18
     19/*
     20 * CPU load counters
     21 * Place in static RAM so updates don't hit the SDRAM
     22 */
     23#define IDLE_COUNTER    __SRAMBASE.idle_counter
     24#define FILTERED_IDLE   __SRAMBASE.filtered_idle
     25#define MAX_IDLE_COUNT  __SRAMBASE.max_idle_count
     26#define PITC_PER_TICK   __SRAMBASE.pitc_per_tick
     27#define NSEC_PER_PITC   __SRAMBASE.nsec_per_pitc
     28#define FILTER_SHIFT    6
    1829
    1930/*
     
    4354}
    4455
     56static void uC5282_tc_at_tick(rtems_timecounter_simple *tc)
     57{
     58  unsigned idle = IDLE_COUNTER;
     59  IDLE_COUNTER = 0;
     60  if (idle > MAX_IDLE_COUNT)
     61    MAX_IDLE_COUNT = idle;
     62  FILTERED_IDLE = idle + FILTERED_IDLE - (FILTERED_IDLE>>FILTER_SHIFT);
     63  MCF5282_PIT3_PCSR |= MCF5282_PIT_PCSR_PIF;
     64}
     65
    4566static void uC5282_tc_tick(void)
    4667{
    47   rtems_timecounter_simple_downcounter_tick(&uC5282_tc, uC5282_tc_get);
     68  rtems_timecounter_simple_downcounter_tick(
     69    &uC5282_tc,
     70    uC5282_tc_get,
     71    uC5282_tc_at_tick
     72  );
    4873}
    49 
    50 /*
    51  * CPU load counters
    52  * Place in static RAM so updates don't hit the SDRAM
    53  */
    54 #define IDLE_COUNTER    __SRAMBASE.idle_counter
    55 #define FILTERED_IDLE   __SRAMBASE.filtered_idle
    56 #define MAX_IDLE_COUNT  __SRAMBASE.max_idle_count
    57 #define PITC_PER_TICK   __SRAMBASE.pitc_per_tick
    58 #define NSEC_PER_PITC   __SRAMBASE.nsec_per_pitc
    59 #define FILTER_SHIFT    6
    60 
    61 /*
    62  * Periodic interval timer interrupt handler
    63  */
    64 #define Clock_driver_support_at_tick()                                       \
    65     do {                                                                     \
    66         unsigned idle = IDLE_COUNTER;                                        \
    67         IDLE_COUNTER = 0;                                                    \
    68         if (idle > MAX_IDLE_COUNT)                                           \
    69             MAX_IDLE_COUNT = idle;                                           \
    70         FILTERED_IDLE = idle + FILTERED_IDLE - (FILTERED_IDLE>>FILTER_SHIFT);\
    71         MCF5282_PIT3_PCSR |= MCF5282_PIT_PCSR_PIF;                           \
    72     } while (0)
    7374
    7475/*
  • c/src/lib/libbsp/powerpc/mpc55xxevb/clock/clock-config.c

    r2b9374e1 r76ac1ee  
    5656}
    5757
    58 static void mpc55xx_tc_tick(void)
    59 {
    60   rtems_timecounter_simple_upcounter_tick(&mpc55xx_tc, mpc55xx_tc_get);
    61 }
    62 
    63 static void mpc55xx_clock_at_tick(void)
     58static void mpc55xx_tc_at_tick(rtems_timecounter_simple *tc)
    6459{
    6560  union EMIOS_CSR_tag csr = MPC55XX_ZERO_FLAGS;
    6661  csr.B.FLAG = 1;
    6762  EMIOS.CH [MPC55XX_CLOCK_EMIOS_CHANNEL].CSR.R = csr.R;
     63}
     64
     65static void mpc55xx_tc_tick(void)
     66{
     67  rtems_timecounter_simple_upcounter_tick(
     68    &mpc55xx_tc,
     69    mpc55xx_tc_get,
     70    mpc55xx_tc_at_tick
     71  );
    6872}
    6973
     
    175179}
    176180
    177 static void mpc55xx_tc_tick(void)
    178 {
    179   rtems_timecounter_simple_downcounter_tick(&mpc55xx_tc, mpc55xx_tc_get);
    180 }
    181 
    182 static void mpc55xx_clock_at_tick(void)
     181static void mpc55xx_tc_at_tick(rtems_timecounter_simple *tc)
    183182{
    184183  volatile PIT_RTI_CHANNEL_tag *channel =
     
    187186
    188187  channel->TFLG.R = tflg.R;
     188}
     189
     190static void mpc55xx_tc_tick(void)
     191{
     192  rtems_timecounter_simple_downcounter_tick(
     193    &mpc55xx_tc,
     194    mpc55xx_tc_get,
     195    mpc55xx_tc_at_tick
     196  );
    189197}
    190198
     
    239247
    240248#define Clock_driver_timecounter_tick() mpc55xx_tc_tick()
    241 #define Clock_driver_support_at_tick() \
    242   mpc55xx_clock_at_tick()
    243249#define Clock_driver_support_initialize_hardware() \
    244250  mpc55xx_clock_initialize()
  • c/src/lib/libbsp/shared/clockdrv_shell.h

    r2b9374e1 r76ac1ee  
    4343#ifndef Clock_driver_support_find_timer
    4444  #define Clock_driver_support_find_timer()
     45#endif
     46
     47/**
     48 * @brief Do nothing by default.
     49 */
     50#ifndef Clock_driver_support_at_tick
     51  #define Clock_driver_support_at_tick()
    4552#endif
    4653
     
    109116            == rtems_configuration_get_idle_task()
    110117      ) {
    111         _Timecounter_Tick_simple(interval, (*tc->tc_get_timecount)(tc));
     118        ISR_lock_Context lock_context;
     119
     120        _Timecounter_Acquire(&lock_context);
     121        _Timecounter_Tick_simple(
     122          interval,
     123          (*tc->tc_get_timecount)(tc),
     124          &lock_context
     125        );
    112126      }
    113127
  • c/src/lib/libbsp/sparc/erc32/clock/ckinit.c

    r2b9374e1 r76ac1ee  
    3737#define CLOCK_VECTOR ERC32_TRAP_TYPE( ERC32_INTERRUPT_REAL_TIME_CLOCK )
    3838
    39 #define Clock_driver_support_at_tick()
    40 
    4139#define Clock_driver_support_install_isr( _new, _old ) \
    4240  do { \
     
    6765}
    6866
     67static void erc32_tc_at_tick( rtems_timecounter_simple *tc )
     68{
     69  /* Nothing to do */
     70}
     71
    6972static void erc32_tc_tick( void )
    7073{
    7174  rtems_timecounter_simple_downcounter_tick(
    7275    &erc32_tc,
    73     erc32_tc_get
     76    erc32_tc_get,
     77    erc32_tc_at_tick
    7478  );
    7579}
  • c/src/lib/libbsp/sparc/leon2/clock/ckinit.c

    r2b9374e1 r76ac1ee  
    5252}
    5353
     54static void leon2_tc_at_tick( rtems_timecounter_simple *tc )
     55{
     56  /* Nothing to do */
     57}
     58
    5459static void leon2_tc_tick( void )
    5560{
    56   rtems_timecounter_simple_downcounter_tick( &leon2_tc, leon2_tc_get );
     61  rtems_timecounter_simple_downcounter_tick(
     62    &leon2_tc,
     63    leon2_tc_get,
     64    leon2_tc_at_tick
     65  );
    5766}
    5867
     
    6271
    6372#define CLOCK_VECTOR LEON_TRAP_TYPE( LEON_INTERRUPT_TIMER1 )
    64 
    65 #define Clock_driver_support_at_tick()
    6673
    6774#define Clock_driver_support_install_isr( _new, _old ) \
  • c/src/lib/libbsp/sparc/leon3/clock/ckinit.c

    r2b9374e1 r76ac1ee  
    7070}
    7171
    72 static void leon3_tc_tick(void)
    73 {
    74   if (leon3_tc_use_irqmp) {
    75     rtems_timecounter_tick();
    76   } else {
    77     rtems_timecounter_simple_downcounter_tick(&leon3_tc, leon3_tc_get);
    78   }
    79 }
    80 
    8172static void leon3_clock_profiling_interrupt_delay(void)
    8273{
     
    112103}
    113104
    114 #define Clock_driver_support_at_tick() \
    115   do { \
    116     leon3_clock_profiling_interrupt_delay(); \
    117   } while (0)
     105static void leon3_tc_at_tick( rtems_timecounter_simple *tc )
     106{
     107  leon3_clock_profiling_interrupt_delay();
     108}
     109
     110static void leon3_tc_tick(void)
     111{
     112  if (leon3_tc_use_irqmp) {
     113    leon3_clock_profiling_interrupt_delay();
     114    rtems_timecounter_tick();
     115  } else {
     116    rtems_timecounter_simple_downcounter_tick(
     117      &leon3_tc,
     118      leon3_tc_get,
     119      leon3_tc_at_tick
     120    );
     121  }
     122}
    118123
    119124#define Adjust_clkirq_for_node() do { clkirq += LEON3_CLOCK_INDEX; } while(0)
  • c/src/lib/libbsp/sparc/shared/timer/tlib_ckinit.c

    r2b9374e1 r76ac1ee  
    3030#undef CLOCK_DRIVER_USE_FAST_IDLE
    3131*/
    32 #define Clock_driver_support_at_tick()
    3332
    3433/*
     
    8887}
    8988
     89static void tlib_tc_at_tick(rtems_timecounter_simple *tc)
     90{
     91  /* Nothing to do? */
     92}
     93
    9094static void tlib_tc_tick(void)
    9195{
    9296  rtems_timecounter_simple_downcounter_tick(
    9397    &tlib_tc,
    94     tlib_tc_get
     98    tlib_tc_get,
     99    tlib_tc_at_tick
    95100  );
    96101}
  • c/src/lib/libcpu/arm/lpc22xx/clock/clockdrv.c

    r2b9374e1 r76ac1ee  
    4646}
    4747
     48/**
     49 * When we get the clock interrupt
     50 *    - clear the interrupt bit?
     51 *    - restart the timer?
     52 */
     53static void lpc22xx_tc_at_tick(rtems_timecounter_simple *tc)
     54{
     55  if (!(T0IR & 0x01))
     56    return;
     57  T0IR = 0x01;
     58  VICVectAddr = 0x00;
     59}
     60
    4861static void lpc22xx_tc_tick(void)
    4962{
    50   rtems_timecounter_simple_upcounter_tick(&lpc22xx_tc, lpc22xx_tc_get);
     63  rtems_timecounter_simple_upcounter_tick(
     64    &lpc22xx_tc,
     65    lpc22xx_tc_get,
     66    lpc22xx_tc_at_tick
     67  );
    5168}
    5269
     
    6279
    6380/* use the /shared/clockdrv_shell.h code template */
    64 
    65 /**
    66  * When we get the clock interrupt
    67  *    - clear the interrupt bit?
    68  *    - restart the timer?
    69  */
    70 #define Clock_driver_support_at_tick() \
    71  do {                                  \
    72    if (!(T0IR & 0x01))                 \
    73      return;                           \
    74    T0IR = 0x01;                        \
    75    VICVectAddr = 0x00;                 \
    76  } while(0)
    7781
    7882/**
  • cpukit/rtems/src/clocktick.c

    r2b9374e1 r76ac1ee  
    2424rtems_status_code rtems_clock_tick( void )
    2525{
     26  ISR_lock_Context lock_context;
     27
     28  _Timecounter_Acquire( &lock_context );
    2629  _Timecounter_Tick_simple(
    2730    rtems_configuration_get_microseconds_per_tick(),
    28     0
     31    0,
     32    &lock_context
    2933  );
    3034
  • cpukit/sapi/include/rtems/timecounter.h

    r2b9374e1 r76ac1ee  
    9595
    9696/**
     97 * @brief At tick handling done under protection of the timecounter lock.
     98 */
     99typedef void rtems_timecounter_simple_at_tick(
     100  rtems_timecounter_simple *tc
     101);
     102
     103/**
    97104 * @brief Returns the current value of a simple timecounter.
    98105 */
     
    200207 * @param[in] tc The simple timecounter.
    201208 * @param[in] get The method to get the value of the simple timecounter.
     209 * @param[in] at_tick The method to perform work under timecounter lock
     210 * protection at this tick, e.g. clear a pending flag.
    202211 */
    203212RTEMS_INLINE_ROUTINE void rtems_timecounter_simple_downcounter_tick(
    204   rtems_timecounter_simple     *tc,
    205   rtems_timecounter_simple_get  get
    206 )
    207 {
     213  rtems_timecounter_simple         *tc,
     214  rtems_timecounter_simple_get      get,
     215  rtems_timecounter_simple_at_tick  at_tick
     216)
     217{
     218  ISR_lock_Context lock_context;
    208219  uint32_t current;
     220
     221  _Timecounter_Acquire( &lock_context );
     222
     223  ( *at_tick )( tc );
    209224
    210225  current = rtems_timecounter_simple_scale(
     
    213228  );
    214229
    215   _Timecounter_Tick_simple( tc->binary_interval, current );
     230  _Timecounter_Tick_simple( tc->binary_interval, current, &lock_context );
    216231}
    217232
     
    221236 * @param[in] tc The simple timecounter.
    222237 * @param[in] get The method to get the value of the simple timecounter.
     238 * @param[in] at_tick The method to perform work under timecounter lock
     239 * protection at this tick, e.g. clear a pending flag.
    223240 */
    224241RTEMS_INLINE_ROUTINE void rtems_timecounter_simple_upcounter_tick(
    225   rtems_timecounter_simple     *tc,
    226   rtems_timecounter_simple_get  get
    227 )
    228 {
     242  rtems_timecounter_simple         *tc,
     243  rtems_timecounter_simple_get      get,
     244  rtems_timecounter_simple_at_tick  at_tick
     245)
     246{
     247  ISR_lock_Context lock_context;
    229248  uint32_t current;
    230249
     250  _Timecounter_Acquire( &lock_context );
     251
     252  ( *at_tick )( tc );
     253
    231254  current = rtems_timecounter_simple_scale( tc, ( *get )( tc ) );
    232255
    233   _Timecounter_Tick_simple( tc->binary_interval, current );
     256  _Timecounter_Tick_simple( tc->binary_interval, current, &lock_context );
    234257}
    235258
  • cpukit/score/include/rtems/score/timecounter.h

    r2b9374e1 r76ac1ee  
    2727#include <sys/timetc.h>
    2828
     29#include <rtems/score/isrlock.h>
     30
    2931#ifdef __cplusplus
    3032extern "C" {
     
    162164
    163165/**
     166 * @brief Lock to protect the timecounter mechanic.
     167 */
     168ISR_LOCK_DECLARE( extern, _Timecounter_Lock )
     169
     170/**
     171 * @brief Acquires the timecounter lock.
     172 *
     173 * @param[in] lock_context The lock context.
     174 *
     175 * See _Timecounter_Tick_simple().
     176 */
     177#define _Timecounter_Acquire( lock_context ) \
     178  _ISR_lock_ISR_disable_and_acquire( &_Timecounter_Lock, lock_context )
     179
     180/**
    164181 * @brief Performs a simple timecounter tick.
    165182 *
     
    170187 * to _Timecounter_Tick_simple().
    171188 * @param[in] offset The current value of the timecounter.
    172  */
    173 void _Timecounter_Tick_simple( uint32_t delta, uint32_t offset );
     189 * @param[in] lock_context The lock context of the corresponding
     190 * _Timecounter_Acquire().
     191 */
     192void _Timecounter_Tick_simple(
     193  uint32_t delta,
     194  uint32_t offset,
     195  ISR_lock_Context *lock_context
     196);
    174197
    175198/**
  • cpukit/score/src/kern_tc.c

    r2b9374e1 r76ac1ee  
    6666#include <limits.h>
    6767#include <rtems.h>
    68 ISR_LOCK_DEFINE(static, _Timecounter_Lock, "Timecounter");
     68ISR_LOCK_DEFINE(, _Timecounter_Lock, "Timecounter")
     69#define _Timecounter_Release(lock_context) \
     70  _ISR_lock_Release_and_ISR_enable(&_Timecounter_Lock, lock_context)
    6971#define hz rtems_clock_get_ticks_per_second()
    7072#define printf(...)
     
    14011403        ISR_lock_Context lock_context;
    14021404
    1403         _ISR_lock_ISR_disable_and_acquire(&_Timecounter_Lock, &lock_context);
     1405        _Timecounter_Acquire(&lock_context);
    14041406#endif /* __rtems__ */
    14051407
     
    15561558#endif /* __rtems__ */
    15571559#ifdef __rtems__
    1558         _ISR_lock_Release_and_ISR_enable(&_Timecounter_Lock, &lock_context);
     1560        _Timecounter_Release(&lock_context);
    15591561#endif /* __rtems__ */
    15601562}
     
    19811983#ifdef __rtems__
    19821984void
    1983 _Timecounter_Tick_simple(uint32_t delta, uint32_t offset)
     1985_Timecounter_Tick_simple(uint32_t delta, uint32_t offset,
     1986    ISR_lock_Context *lock_context)
    19841987{
    19851988        struct bintime bt;
    19861989        struct timehands *th;
    19871990        uint32_t ogen;
    1988         ISR_lock_Context lock_context;
    1989 
    1990         _ISR_lock_ISR_disable_and_acquire(&_Timecounter_Lock, &lock_context);
    19911991
    19921992        th = timehands;
     
    20152015        time_uptime = th->th_offset.sec;
    20162016
    2017         _ISR_lock_Release_and_ISR_enable(&_Timecounter_Lock, &lock_context);
     2017        _Timecounter_Release(lock_context);
    20182018
    20192019        _Watchdog_Tick();
  • doc/bsp_howto/clock.t

    r2b9374e1 r76ac1ee  
    9090@}
    9191
     92static void some_tc_at_tick( rtems_timecounter_simple *tc )
     93@{
     94  /*
     95   * Do work necessary at the clock tick interrupt, e.g. clear a pending flag.
     96   */
     97@}
     98
    9299static bool some_tc_is_pending( rtems_timecounter_simple *tc )
    93100@{
     
    106113static void some_tc_tick( void )
    107114@{
    108   rtems_timecounter_simple_downcounter_tick( &some_tc, some_tc_get );
     115  rtems_timecounter_simple_downcounter_tick(
     116    &some_tc,
     117    some_tc_get,
     118    some_tc_at_tick
     119  );
    109120@}
    110121
Note: See TracChangeset for help on using the changeset viewer.