/home/hillier_g/checkout/most4linux/most-kernel/rt-nrt.h

Go to the documentation of this file.

/*
 *  Copyright(c) Siemens AG, Muenchen, Germany, 2005, 2006, 2007
 *                           Bernhard Walle <bernhard.walle@gmx.de>
 *                           Gernot Hillier <gernot.hillier@siemens.com>
 *
 * ----------------------------------------------------------------------------
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as 
 * published by the Free Software Foundation;
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 * ----------------------------------------------------------------------------
 */
#ifndef RT_NRT_H
#define RT_NRT_H

#ifdef HAVE_CONFIG_H
#include "config/config.h"
#endif
#include <asm/uaccess.h>
#include <asm/div64.h>
#include <linux/version.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/delay.h>

#ifdef RT_RTDM
#   include <rtdm/rtdm_driver.h>
#   include "rtseqlock.h"
#   ifdef XENO_VERSION_NAME
#       include <native/timer.h>
#   endif
#endif
 /* {{{ */

#if defined(RT_RTDM) || defined(DOXYGEN)

#define rt_nrt_exec(rt, nrt)                                \
    rt

#if defined(XENO_VERSION_NAME) || defined(DOXYGEN)

#define rtnrt_start_timer_oneshot()                         \
    rt_timer_set_mode(TM_ONESHOT)
#elif defined(RTAI_RELEASE)
#define rtnrt_start_timer_oneshot()                         \
    start_rt_timer(0)
#else
#error "Unsupported operating system for RTDM"
#endif

#else

#define rt_nrt_exec(rt, nrt)                                \
    nrt

#define rtnrt_start_timer_oneshot()                         \
    0

#endif /* RT_RTDM */
 /* }}} */

 /* {{{ */

#if defined(RT_RTDM) || defined(DOXYGEN)

#define rtnrt_printk(fmt, arg...) \
        rtdm_printk(fmt, ##arg)
#else

#define rtnrt_printk(fmt, arg...) \
        printk(fmt, ##arg)

#endif

#if defined(DEBUG) || defined(DOXYGEN)

#define rtnrt_debug(fmt, arg...) \
        rtnrt_printk(KERN_DEBUG fmt, ##arg)
#else

#define rtnrt_debug(fmt, arg...) \
        do { } while (0)
#endif

#   define rtnrt_info(fmt, arg...) \
        rtnrt_printk(KERN_INFO fmt, ##arg)


#define rtnrt_notice(fmt, arg...) \
    rtnrt_printk(KERN_NOTICE fmt,##arg)

#define rtnrt_warn(fmt, arg...) \
    rtnrt_printk(KERN_WARNING "- " fmt,##arg)

#define rtnrt_err(fmt, arg...) \
    rtnrt_printk(KERN_ERR "* " fmt,##arg)

#define rtnrt_crit(fmt, arg...) \
    rtnrt_printk(KERN_CRIT "# " fmt,##arg)

#define rtnrt_alert(fmt, arg...) \
    rtnrt_printk(KERN_ALERT "!!!! " fmt,##arg)

#define rtnrt_emeg(fmt, arg...) \
    rtnrt_printk(KERN_EMERG "***!!!!*** " fmt,##arg)

 /* }}} */

 /* {{{ */
#if defined(CONFIG_PREEMPT_RT) || defined(DOXYGEN)

#   define RTNRT_LSPINLOCK_UNLOCKED(lock)                  \
        SPIN_LOCK_UNLOCKED(lock)
#else
#   define RTNRT_LSPINLOCK_UNLOCKED(lock)                  \
        SPIN_LOCK_UNLOCKED
#endif


#if defined(RT_RTDM) || defined(DOXYGEN)

#define RTNRT_LOCK_UNLOCKED(lock)                          \
    RTDM_LOCK_UNLOCKED

#define rtnrt_lock_init(lock)                               \
    rtdm_lock_init(lock)

#define rtnrt_lock_get(lock)                                \
    rtdm_lock_get(lock)

#define rtnrt_lock_put(lock)                                \
    rtdm_lock_put(lock)

#define rtnrt_lock_get_irqsave(lock, flags)                 \
    rtdm_lock_get_irqsave(lock, flags)

#define rtnrt_lock_put_irqrestore(lock, flags)              \
    rtdm_lock_put_irqrestore(lock, flags)

typedef rtdm_lock_t rtnrt_lock_t;

typedef rtdm_lockctx_t rtnrt_lockctx_t;

#else /* NRT variant */

#if defined(CONFIG_PREEMPT_RT)
#   define RTNRT_LOCK_UNLOCKED(lock)                        \
        SPIN_LOCK_UNLOCKED(lock)
#else /* not CONFIG_PREEMPT_RT */
#   define RTNRT_LOCK_UNLOCKED(lock)                        \
        SPIN_LOCK_UNLOCKED
#endif /* CONFIG_PREEMPT_RT */

#define rtnrt_lock_init(lock)                               \
    spin_lock_init(lock)

#define rtnrt_lock_get(lock)                                \
    spin_lock(lock)

#define rtnrt_lock_put(lock)                                \
    spin_unlock(lock)

#define rtnrt_lock_get_irqsave(lock, flags)                 \
    spin_lock_irqsave(lock, flags)

#define rtnrt_lock_put_irqrestore(lock, flags)              \
    spin_unlock_irqrestore(lock, flags)

typedef spinlock_t rtnrt_lock_t;

typedef unsigned long rtnrt_lockctx_t;

#endif
 /* }}} */
 /* {{{ */
#if defined(RT_RTDM) || defined(DOXYGEN)

#define RTNRT_SEQLOCK_UNLOCKED                       \
    RT_SEQLOCK_UNLOCKED

#define rtnrt_seqlock_init(x)                        \
    rt_seqlock_init(x)

#define rtnrt_write_seqlock(sl)                      \
    rt_write_seqlock(seqlock_t *sl)

#define rtnrt_write_sequnlock(sl)                    \
    rt_write_sequnlock(seqlock_t *sl)

#define rtnrt_read_seqbegin(sl)                      \
    rt_read_seqbegin(sl)

#define rtnrt_read_seqretry(sl, iv)                   \
    rt_read_seqretry(sl, iv)

#define rtnrt_write_seqlock_irqsave(sl, flags)        \
    rt_write_seqlock_irqsave(sl, flags)

#define rtnrt_write_sequnlock_irqrestore(sl, flags)   \
    rt_write_sequnlock_irqrestore(sl, flags)

typedef rt_seqlock_t rtnrt_seqlock_t;

#else

#define RTNRT_SEQLOCK_UNLOCKED                       \
    SEQLOCK_UNLOCKED

#define rtnrt_seqlock_init(x)                        \
    seqlock_init(x)

#define rtnrt_write_seqlock(sl)                      \
    write_seqlock(seqlock_t *sl)

#define rtnrt_write_sequnlock(sl)                    \
    write_sequnlock(seqlock_t *sl)

#define rtnrt_read_seqbegin(sl)                      \
    read_seqbegin(sl)

#define rtnrt_read_seqretry(sl, iv)                  \
    read_seqretry(sl, iv)

#define rtnrt_write_seqlock_irqsave(sl, flags)       \
    write_seqlock_irqsave(sl, flags)

#define rtnrt_write_sequnlock_irqrestore(sl, flags)  \
    write_sequnlock_irqrestore(sl, flags)

typedef seqlock_t rtnrt_seqlock_t;



#endif
 /* }}} */
 /* {{{ */

#if !defined(NSEC_PER_MSEC) || defined(DOXYGEN)
#define NSEC_PER_MSEC       1000000L
#endif

#if (defined(RTDM_API_VER) && (RTDM_API_VER < 5)) || defined (DOXYGEN) \
    || !defined(RTDM_API_VER)

typedef uint64_t nanosecs_abs_t;

typedef uint64_t nanosecs_rel_t;

#endif

#if defined(RT_RTDM) || defined(DOXYGEN)

static inline nanosecs_abs_t rtnrt_clock_read(void)
{
    return rtdm_clock_read();
}

#else

static inline nanosecs_abs_t rtnrt_clock_read(void)
{
    struct timespec ts;

    getnstimeofday(&ts);
    return (nanosecs_abs_t)ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
}

#endif
 /* }}} */
 /* {{{ */

#if defined(RT_RTDM) || defined(DOXYGEN)

static inline int rtnrt_task_sleep(unsigned int millisecs)
{
    nanosecs_abs_t      sleep_until;
    nanosecs_rel_t      delay;
    int                 ret;

    delay = millisecs * NSEC_PER_MSEC;
    sleep_until = rtnrt_clock_read() + delay;

    ret = rtdm_task_sleep(delay);
    if (ret == -EINTR) {
        uint64_t time_left = sleep_until - rtnrt_clock_read();
        do_div(time_left, NSEC_PER_MSEC);

        /* return not zero because of rounding issues */
        return time_left == 0 ? 1 : time_left; 
    }

    return ret;
}

#define rtnrt_ndelay(delay_nsecs)                           \
    rtdm_task_busy_sleep(delay_nsecs)

#define rtnrt_udelay(delay_usecs)                           \
    rtdm_task_busy_sleep((delay_usecs) * NSEC_PER_USEC)

#define rtnrt_mdelay(delay_msecs)                           \
    rtdm_task_busy_sleep((delay_msecs) * NSEC_PER_MSEC)

#else

static inline int rtnrt_task_sleep(unsigned int millisecs)
{
    return msleep_interruptible(millisecs);
}

#define rtnrt_ndelay(delay_nsecs)                           \
    ndelay(delay_nsecs)
#define rtnrt_udelay(delay_usecs)                           \
    udelay(delay_usecs)
#define rtnrt_mdelay(delay_msecs)                           \
    mdelay(delay_msecs)

#endif
 /* }}} */
 /* {{{ */

typedef unsigned long (*rtnrt_memcopy_func)(void              *to, 
                                            const void        *from, 
                                            unsigned long     count,
                                            void              *cookie);


struct rtnrt_memcopy_desc {
    rtnrt_memcopy_func  function;       
    void                *cookie;        
};

static inline unsigned long rtnrt_memmove(void              *to,
                                         const void         *from,
                                         unsigned long      count,
                                         void               *cookie)
{
    memmove(to, from, count);
    return 0;
}

static inline unsigned long rtnrt_copy_to_user(void              *to, 
                                              const void         *from,
                                              unsigned long      count,
                                              void               *cookie)
{
    return copy_to_user(to, from, count);
}

static inline unsigned long rtnrt_copy_from_user(void              *to, 
                                                const void         *from, 
                                                unsigned long      count,
                                                void               *cookie)
{
    return copy_from_user(to, from, count);
}

#ifdef RT_RTDM

static inline unsigned long rtnrt_copy_to_user_rt(void              *to, 
                                                 const void         *from, 
                                                 unsigned long      count,
                                                 void               *cookie)
{
    rtdm_user_info_t *user_info = (rtdm_user_info_t *)cookie;
    
    if (user_info) {
        unsigned long ret;
        
        ret = rtdm_copy_to_user(user_info, to, from, count);
        return (ret < 0) ? count : 0;
    } else {
        memcpy(to, from, count);
        return 0;
    }
}

static inline unsigned long rtnrt_copy_from_user_rt(void              *to, 
                                                   const void         *from, 
                                                   unsigned long      count,
                                                   void               *cookie)
{
    rtdm_user_info_t *user_info = (rtdm_user_info_t *)cookie;

    if (user_info) {
        unsigned long ret;
        
        ret = rtdm_copy_from_user(user_info, to, from, count);
        return (ret < 0) ? count : 0;
    } else {
        memcpy(to, from, count);
        return 0;
    }
}

#endif

#define rtnrt_copy(desc, to, from, count)   \
    (desc)->function(to, from, count, (desc)->cookie)
 /* }}} */
 /* {{{ */

#if defined(RT_RTDM) || defined(DOXYGEN)

#define DEFINE_NRTSIG(name)                          \
    static rtdm_nrtsig_t name

#define rtnrt_nrtsig_init(nrt_sig, handler)          \
    rtdm_nrtsig_init(nrt_sig, handler)

#define rtnrt_nrtsig_destroy(nrt_sig)                \
    rtdm_nrtsig_destroy(nrt_sig)

#define rtnrt_nrtsig_action(nrt_sig, handler)        \
    rtdm_nrtsig_pend(nrt_sig)

typedef rtdm_nrtsig_t rtnrt_nrtsig_t;

#else

#define DEFINE_NRTSIG(name)

#define rtnrt_nrtsig_init(nrt_sig, handler)      0

#define rtnrt_nrtsig_destroy(nrt_sig) \
    do {} while (0)

#define rtnrt_nrtsig_action(nrt_sig, handler)            \
    handler(NULL)

typedef void * rtnrt_nrtsig_t;

#endif
 /* }}} */
 /* {{{ */

/* compatibility accross various RTDM versions */

#if defined(RT_RTDM) || defined(DOXYGEN)
#if !defined(RTDM_IRQTYPE_SHARED) || defined(DOXYGEN)

#   define RTDM_IRQTYPE_SHARED      0
#endif /* RTDM_IRQTYPE_SHARED */


#if !defined(RTDM_IRQ_NONE) || defined(DOXYGEN)

#   define RTDM_IRQ_NONE            0
#endif /* RTDM_IRQ_NONE */

#if !defined(RTDM_IRQ_HANDLED) || defined(DOXYGEN)

#   define RTDM_IRQ_HANDLED         0
#endif /* RTDM_IRQ_HANDLED */

#if !defined(RTDM_IRQ_ENABLE) || defined(DOXYGEN)

#define RTDM_IRQ_ENABLE             0
#endif /* RTDM_IRQ_ENABLE */
#endif /* RT_RTDM */

#if defined(RT_RTDM) || defined(DOXYGEN)

#define DECLARE_IRQ_PROXY(proxy_name, calling_function, arg_type)         \
    static int proxy_name(rtdm_irq_t *irq_handle)                         \
    {                                                                     \
        return calling_function(rtdm_irq_get_arg(irq_handle, arg_type));  \
    }

#define RTNRT_IRQ_HANDLED                                                 \
    (RTDM_IRQ_HANDLED | RTDM_IRQ_ENABLE)

#define RTNRT_IRQ_NONE                                                    \
    (RTDM_IRQ_NONE | RTDM_IRQ_ENABLE)

typedef int rtnrt_irqreturn_t;

#define rtnrt_register_interrupt_handler(rtdm_irq_handle,                 \
                                        interrupt_line,                   \
                                        interrupt_handler,                \
                                        shared,                           \
                                        device_name,                      \
                                        cookie)                           \
    rtdm_irq_request(rtdm_irq_handle, interrupt_line, int_handler,        \
            shared, device_name, cookie)

#define rtnrt_irq_enable(rtdm_irq_handle)                                 \
    rtdm_irq_enable(rtdm_irq_handle)

#define rtnrt_free_interrupt_handler(rtdm_irq_handle,                     \
                                    interrupt_line,                       \
                                    device_name)                          \
    rtdm_irq_free(rtdm_irq_handle);

#else /* not RT_RTDM */

#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18))
#define DECLARE_IRQ_PROXY(proxy_name, calling_function, arg_type)         \
    static irqreturn_t proxy_name(int              irq,                   \
                                      void             *dev_id,           \
                                      struct pt_regs   *regs)             \
    {                                                                     \
        return calling_function((arg_type *)dev_id);                      \
    }

#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19))
#define DECLARE_IRQ_PROXY(proxy_name, calling_function, arg_type)         \
    static irqreturn_t proxy_name(int              irq,                   \
                                      void             *dev_id)           \
    {                                                                     \
        return calling_function((arg_type *)dev_id);                      \
    }
#endif


#define RTNRT_IRQ_HANDLED                                                 \
    IRQ_HANDLED

#define RTNRT_IRQ_NONE                                                    \
    IRQ_NONE

typedef irqreturn_t rtnrt_irqreturn_t;

#define rtnrt_register_interrupt_handler(rtdm_irq_handle,                 \
                                        interrupt_line,                   \
                                        interrupt_handler,                \
                                        shared,                           \
                                        device_name,                      \
                                        cookie)                           \
    request_irq(interrupt_line, interrupt_handler, shared,                \
            device_name, cookie)

#define rtnrt_irq_enable(rtdm_irq_handle)                                 \
    0

#define rtnrt_free_interrupt_handler(rtdm_irq_handle,                     \
                                    interrupt_line,                       \
                                    device_name)                          \
    free_irq(interrupt_line, device_name)

#endif /* RT_RTDM */
 /* }}} */


#endif /* RT_NRT_H */

/* vim: set ts=4 et sw=4 foldmethod=marker: */

---