Subversion Repositories openrisc

//==========================================================================
//
//      time.cxx
//
//      POSIX time functions implementation
//
//==========================================================================
// ####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):           nickg
// Contributors:        nickg
// Date:                2000-03-27
// Purpose:             POSIX time functions implementation
// Description:         This file contains the implementation of the POSIX time
//                      functions.
//              
//              
//
//####DESCRIPTIONEND####
//
//==========================================================================
 
#include <pkgconf/posix.h>
 
#include <pkgconf/hal.h>
#include <pkgconf/kernel.h>
 
#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 "pprivate.h"                   // POSIX private header
 
#include <time.h>                       // our header
#include <sys/time.h>
 
#include <cyg/kernel/thread.hxx>
#include <cyg/kernel/clock.hxx>
#include <cyg/kernel/kapi.h>
 
#include <cyg/kernel/thread.inl>
#include <cyg/kernel/clock.inl>
 
// -------------------------------------------------------------------------
// Internal definitions
 
// Handle entry to a pthread package function. 
#define TIME_ENTRY() CYG_REPORT_FUNCTYPE( "returning %d" );
 
// Do a time package defined return. This requires the error code
// to be placed in errno, and if it is non-zero, -1 returned as the
// result of the function. This also gives us a place to put any
// generic tidyup handling needed for things like signal delivery and
// cancellation.
#define TIME_RETURN(err)                        \
CYG_MACRO_START                                 \
    int __retval = 0;                           \
    if( err != 0 ) __retval = -1, errno = err;  \
    CYG_REPORT_RETVAL( __retval );              \
    return __retval;                            \
CYG_MACRO_END
 
//==========================================================================
// Timer control structures
 
#ifdef CYGPKG_POSIX_TIMERS
typedef struct
{
    timer_t             id;             // id value for checking
    Cyg_Alarm           *alarm;         // eCos alarm object
    cyg_bool            armed;          // is alarm enabled?
    cyg_bool            pending;        // is expiry pending?
    int                 overrun;        // Overrun count
    struct sigevent     sigev;          // Sigevent to raise on expiry
 
    // Space for alarm object
    cyg_uint8           alarm_obj[sizeof(Cyg_Alarm)];
 
} posix_timer;
 
// Mutex for controlling access to shared data structures
static Cyg_Mutex timer_mutex CYGBLD_POSIX_INIT;
 
// Array of timer objects
static posix_timer timer_table[_POSIX_TIMER_MAX];
 
// Index of next timer to allocate from array
static int timer_next = 0;
 
// This is used to make timer_t values unique even when reusing
// a table slot. This allows _POSIX_TIMER_MAX to range
// up to 1024.
#define TIMER_ID_COOKIE_INC 0x00000400
#define TIMER_ID_COOKIE_MASK (TIMER_ID_COOKIE_INC-1)
static timer_t timer_id_cookie = TIMER_ID_COOKIE_INC;
 
#endif // ifdef CYGPKG_POSIX_TIMERS
 
//-----------------------------------------------------------------------------
// new operator to allow us to invoke the constructor on
// posix_timer.alarm_obj.
 
inline void *operator new(size_t size,  cyg_uint8 *ptr) { return (void *)ptr; };
 
//==========================================================================
// Time conversion variables
// These are used to interconvert between ticks and POSIX timespecs.
 
// Converters from sec and ns to ticks
static struct Cyg_Clock::converter ns_converter, sec_converter;
 
// Converters from ticks to sec and ns
static struct Cyg_Clock::converter ns_inverter, sec_inverter;
 
// tickns is the number of nanoseconds per tick.
static cyg_tick_count tickns;
 
static cyg_bool converters_initialized = false;
 
//==========================================================================
// Local functions
 
static void init_converters()
{
    if( !converters_initialized )
    {
 
        // Create the converters we need.
        Cyg_Clock::real_time_clock->get_other_to_clock_converter( 1, &ns_converter );
        Cyg_Clock::real_time_clock->get_other_to_clock_converter( 1000000000, &sec_converter );
        Cyg_Clock::real_time_clock->get_clock_to_other_converter( 1, &ns_inverter );    
        Cyg_Clock::real_time_clock->get_clock_to_other_converter( 1000000000, &sec_inverter );
 
        tickns = Cyg_Clock::convert( 1, &ns_inverter );
 
        converters_initialized = true;
    }
}
 
static cyg_bool valid_timespec( const struct timespec *tp )
{
    // Fail a NULL pointer
    if( tp == NULL ) return false;
 
    // Fail illegal nanosecond values
    if( tp->tv_nsec < 0 || tp->tv_nsec > 1000000000 )
        return false;
 
    return true;
}
 
externC cyg_tick_count cyg_timespec_to_ticks( const struct timespec *tp,
                                              cyg_bool roundup)
{
    init_converters();
 
    // Short circuit zero timespecs
    if( tp->tv_sec == 0 && tp->tv_nsec == 0 )
    {
        return 0;
    }
 
    // Convert the seconds field to ticks.
    cyg_tick_count ticks = Cyg_Clock::convert( tp->tv_sec, &sec_converter );
 
    if( roundup )
    {
        // Convert the nanoseconds. We add (tickns-1) to round the value up
        // to the next whole tick.
 
        ticks += Cyg_Clock::convert( (cyg_tick_count)tp->tv_nsec+tickns-1, &ns_converter );    
    }
    else
    {
        // Convert the nanoseconds. This will round down to nearest whole tick.
        ticks += Cyg_Clock::convert( (cyg_tick_count)tp->tv_nsec, &ns_converter );
    }
 
    return ticks;
}
 
externC void cyg_ticks_to_timespec( cyg_tick_count ticks, struct timespec *tp )
{
    init_converters();
 
    // short circuit zero ticks values
    if( ticks == 0 )
    {
        tp->tv_sec = 0;
        tp->tv_nsec = 0;
        return;
    }
 
    // Convert everything to nanoseconds with a long long. For 64-bits,
    // this is safe for 544 years. We'll think about it more closer to
    // the time...
 
    unsigned long long nsecs = Cyg_Clock::convert( ticks, &ns_inverter );
 
    tp->tv_sec = (long)(nsecs / 1000000000ll);
    tp->tv_nsec = (long)(nsecs % 1000000000ll);
 
    CYG_POSTCONDITION(valid_timespec(tp), "Failed to make valid timespec!");
}
 
//==========================================================================
// Startup routine.
 
externC void cyg_posix_clock_start()
{
    init_converters();
}
 
#ifdef CYGPKG_POSIX_TIMERS
//==========================================================================
// Alarm action routine
// This is called each time an alarm set up by a timer expires.
 
static void alarm_action( Cyg_Alarm *alarm, CYG_ADDRWORD data )
{
    posix_timer *timer = (posix_timer *)data;
 
    if( timer->pending )
    {
        // If the pending flag is already set, count an overrun and
        // do not bother to try and deliver the expiry.
 
        timer->overrun++;
    }
    else
    {
        if( timer->sigev.sigev_notify == SIGEV_SIGNAL )
        {
            // Set the expiry pending and wake a thread to
            // deliver the signal.
 
            timer->pending = true;
 
            sigset_t mask;
            sigemptyset( &mask );
            sigaddset( &mask, timer->sigev.sigev_signo );
            cyg_posix_signal_sigwait();
            cyg_posix_pthread_release_thread( &mask );
        }
        else if( timer->sigev.sigev_notify == SIGEV_THREAD )
        {
            // Thread style notification
            // FIXME: implement SIGEV_THREAD
        }
        // else do nothing
    }
}
 
//==========================================================================
// Timer ASR routine
 
externC void cyg_posix_timer_asr( pthread_info *self )
{
 
    // Loop over the timers looking for any that have an
    // expiry pending and call cyg_sigqueue() for each.
 
    for( int i = 0; i < _POSIX_TIMER_MAX; i++ )
    {
        posix_timer *timer = &timer_table[i];
 
        if( timer->id != 0 && timer->pending )
        {
            timer->pending = false;
 
            // Call into signal subsystem...
            cyg_sigqueue( &timer->sigev, SI_TIMER );
 
            timer->overrun = 0;
        }
    }
}
 
#endif // ifdef CYGPKG_POSIX_TIMERS
 
//==========================================================================
// Clock functions
 
//-----------------------------------------------------------------------------
// Set the clocks current time
 
externC int clock_settime( clockid_t clock_id, const struct timespec *tp)
{
    TIME_ENTRY();
 
    if( clock_id != CLOCK_REALTIME )
        TIME_RETURN(EINVAL);
 
    if( !valid_timespec( tp ) )
        TIME_RETURN(EINVAL);
 
    cyg_tick_count ticks = cyg_timespec_to_ticks( tp );
 
    Cyg_Clock::real_time_clock->set_value( ticks );
 
    TIME_RETURN(0);
}
 
//-----------------------------------------------------------------------------
// Get the clocks current time
 
externC int clock_gettime( clockid_t clock_id, struct timespec *tp)
{
    TIME_ENTRY();
 
    if( clock_id != CLOCK_REALTIME )
        TIME_RETURN(EINVAL);
 
    if( tp == NULL )
        TIME_RETURN(EINVAL);
 
    cyg_tick_count ticks = Cyg_Clock::real_time_clock->current_value();
 
    cyg_ticks_to_timespec( ticks, tp );
 
    TIME_RETURN(0);
}
 
 
//-----------------------------------------------------------------------------
// Get the clocks resolution
 
externC int clock_getres( clockid_t clock_id, struct timespec *tp)
{
    TIME_ENTRY();
 
    if( clock_id != CLOCK_REALTIME )
        TIME_RETURN(EINVAL);
 
    if( tp == NULL )
        TIME_RETURN(EINVAL);
 
    // Get the resolution of 1 tick
    cyg_ticks_to_timespec( 1, tp );
 
    TIME_RETURN(0);
}
 
 
//==========================================================================
// Timer functions
 
#ifdef CYGPKG_POSIX_TIMERS
 
//-----------------------------------------------------------------------------
// Create a timer based on the given clock.
 
externC int timer_create( clockid_t clock_id,
                          struct sigevent *evp,
                          timer_t *timer_id)
{
    TIME_ENTRY();
 
    if( clock_id != CLOCK_REALTIME )
        TIME_RETURN(EINVAL);
 
    timer_mutex.lock();
 
    posix_timer *timer;
    int next = timer_next;
 
    // Look for an unused slot in the table
    while( timer_table[next].id != 0 )
    {
        next++;
        if( next >= _POSIX_TIMER_MAX )
            next = 0;
 
        if( next == timer_next )
        {
            timer_mutex.unlock();
            TIME_RETURN(EAGAIN);
        }
    }
 
    timer = &timer_table[next];
 
    timer_next = next;
 
    // Make sure we never allocate a zero timer id.
    while( timer->id == 0 )
    {
        timer_id_cookie += TIMER_ID_COOKIE_INC;
        timer->id        = next+timer_id_cookie;
    }
 
    if( evp == NULL )
    {
        // If no evp is supplied, set up the timer
        // to use a default set.
        timer->sigev.sigev_notify               = SIGEV_SIGNAL;
        timer->sigev.sigev_signo                = SIGALRM;
        timer->sigev.sigev_value.sival_int      = timer->id;
    }
    else timer->sigev = *evp;
 
    timer->alarm        = new( timer->alarm_obj )
                               Cyg_Alarm( Cyg_Clock::real_time_clock,
                                          alarm_action,
                                          (CYG_ADDRWORD)timer );
 
    timer->armed        = false;
    timer->overrun      = 0;
 
    *timer_id = timer->id;
 
    timer_mutex.unlock();
 
    TIME_RETURN(0);
}
 
//-----------------------------------------------------------------------------
// Delete the timer
 
externC int timer_delete( timer_t timerid )
{
    int err = EINVAL;
    TIME_ENTRY();
 
    posix_timer *timer = &timer_table[timerid & TIMER_ID_COOKIE_MASK];
 
    timer_mutex.lock();
 
    if( timer->id == timerid )
    {
        // This is a valid timer, disable the kernel
        // alarm and delete it.
 
        // disable alarm
        timer->alarm->disable();
 
        // destroy it
        timer->alarm->~Cyg_Alarm();
 
        // Mark POSIX timer free
        timer->id = 0;
 
        err = 0;
    }
 
    timer_mutex.unlock();
 
    TIME_RETURN( err );
}
 
//-----------------------------------------------------------------------------
// Set the expiration time of the timer.
 
externC int timer_settime( timer_t timerid, int flags,
                           const struct itimerspec *value,
                           struct itimerspec *ovalue )
{
    int err = EINVAL;
    TIME_ENTRY();
 
    if( value == NULL )
        TIME_RETURN(EINVAL);
 
    // convert trigger and interval values to ticks.
    cyg_tick_count trigger = cyg_timespec_to_ticks( &value->it_value, true );
    cyg_tick_count interval = cyg_timespec_to_ticks( &value->it_interval, true );
 
    posix_timer *timer = &timer_table[timerid & TIMER_ID_COOKIE_MASK];
 
    timer_mutex.lock();
 
    if( timer->id == timerid )
    {
        // disable the timer
        timer->alarm->disable();
 
        if( ovalue != NULL )
        {
            cyg_tick_count otrigger, ointerval;
 
            timer->alarm->get_times( &otrigger, &ointerval );
 
            if( timer->armed )
            {
                // convert absolute trigger time to interval until next trigger
                otrigger -= Cyg_Clock::real_time_clock->current_value();
            }
            else otrigger = 0;
 
            // convert ticks to timespecs
            cyg_ticks_to_timespec( otrigger, &ovalue->it_value );
            cyg_ticks_to_timespec( ointerval, &ovalue->it_interval );
        }
 
        if( trigger == 0 )
        {
            // Mark timer disarmed
            timer->armed = false;            
        }
        else
        {
            // If the ABSTIME flag is not set, add the current time
            if( (flags & TIMER_ABSTIME) == 0 )
                trigger += Cyg_Clock::real_time_clock->current_value();
 
            // Set the alarm running.
            timer->alarm->initialize( trigger, interval );
 
            // Mark timer armed
            timer->armed = true;
 
        }
 
        err = 0;
    }
 
    timer_mutex.unlock();
 
    TIME_RETURN(err);
}
 
//-----------------------------------------------------------------------------
// Get current timer values
 
externC int timer_gettime( timer_t timerid, struct itimerspec *value )
{
    int err = EINVAL;
 
    TIME_ENTRY();
 
    if( value == NULL )
        TIME_RETURN(EINVAL);
 
    posix_timer *timer = &timer_table[timerid & TIMER_ID_COOKIE_MASK];
 
    timer_mutex.lock();
 
    if( timer->id == timerid )
    {
        cyg_tick_count trigger, interval;
 
        timer->alarm->get_times( &trigger, &interval );
 
        if( timer->armed )
        {
            // convert absolute trigger time to interval until next trigger
            trigger -= Cyg_Clock::real_time_clock->current_value();
        }
        else trigger = 0;
 
        // convert ticks to timespecs
        cyg_ticks_to_timespec( trigger, &value->it_value );
        cyg_ticks_to_timespec( interval, &value->it_interval );
        err = 0;
    }
 
    timer_mutex.unlock();
 
    TIME_RETURN(err);
}
 
//-----------------------------------------------------------------------------
// Get number of missed triggers
 
externC int timer_getoverrun( timer_t timerid )
{
    int overrun = 0;
 
    TIME_ENTRY();
 
    posix_timer *timer = &timer_table[timerid & TIMER_ID_COOKIE_MASK];
 
    timer_mutex.lock();
 
    if( timer->id == timerid )
    {
        overrun = timer->overrun;
    }
 
    timer_mutex.unlock();
 
    CYG_REPORT_RETVAL(overrun);
    return overrun;
}
 
#endif // ifdef CYGPKG_POSIX_TIMERS
 
//==========================================================================
// Nanosleep
// Sleep for the given time.
 
externC int nanosleep( const struct timespec *rqtp,
                       struct timespec *rmtp)
{
    cyg_tick_count ticks, now, then;
 
    TIME_ENTRY();
 
    // check for cancellation first.
    PTHREAD_TESTCANCEL();
 
    // Fail an invalid timespec
    if( !valid_timespec( rqtp ) )
        TIME_RETURN(EINVAL);
 
    // Return immediately for a zero delay.
    if( rqtp->tv_sec == 0 && rqtp->tv_nsec == 0 )
        TIME_RETURN(0);
 
    // Convert timespec to ticks
    ticks = cyg_timespec_to_ticks( rqtp, true );
 
    CYG_ASSERT( ticks != 0, "Zero tick count");
 
    Cyg_Thread *self = Cyg_Thread::self();
 
    // Do the delay, keeping track of how long we actually slept for.
    then = Cyg_Clock::real_time_clock->current_value();
 
    self->delay( ticks );
 
    now = Cyg_Clock::real_time_clock->current_value();
 
 
    if( rmtp != NULL && (then+ticks) > now )
    {
        // We woke up early, return the time left.
        // FIXME: strictly we only need to do this if we were woken
        //        by a signal.
 
        // Calculate remaining number of ticks.
        ticks -= (now-then);
 
        cyg_ticks_to_timespec( ticks, rmtp );
 
        // Check for cancellation and then notify the caller that we
        // were interrupted.
        PTHREAD_TESTCANCEL();
        TIME_RETURN(EINTR);
    }
 
    // check if we were woken up because we were cancelled.
    PTHREAD_TESTCANCEL();
 
    TIME_RETURN(0);
}    
 
// -------------------------------------------------------------------------
// Wait for a signal, or the given number of seconds
 
externC unsigned int sleep( unsigned int seconds )
{
    TIME_ENTRY();
 
    struct timespec timeout;
 
    timeout.tv_sec = seconds;
    timeout.tv_nsec = 0;
 
    if( nanosleep( &timeout, &timeout ) != 0 )
    {
        CYG_REPORT_RETVAL(timeout.tv_sec);
        return timeout.tv_sec;
    }
 
    TIME_RETURN(0);
} 
 
// -------------------------------------------------------------------------
// gettimeofday()
// Get the current time in a struct timeval
externC int gettimeofday(struct timeval* tv, struct timezone* tz)
{
    int ticks_per_second = 1000000000/
      (CYGNUM_HAL_RTC_NUMERATOR/CYGNUM_HAL_RTC_DENOMINATOR);    
    cyg_tick_count_t cur_time = cyg_current_time();
    int tix = cur_time % ticks_per_second;
    tv->tv_sec = cur_time / ticks_per_second;
    tv->tv_usec = (tix * 1000000)/ticks_per_second;
    return 0;
}
 
 
// -------------------------------------------------------------------------
// EOF time.cxx