/home/hillier_g/checkout/most4linux/most-kernel/most-common.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 MOST_COMMON_H
#define MOST_COMMON_H

#ifdef HAVE_CONFIG_H
#include "config/config.h"
#endif
#ifdef __KERNEL__
#   include <linux/version.h>
#   include <linux/spinlock.h>
#   include <linux/rwsem.h>
#   include <linux/list.h>
#   include <linux/delay.h>
#   include "most-constants.h"
#   include "rt-nrt.h"
#endif

#include <asm/types.h>

struct frame_part {
    __u32    count;         
    __u32    offset;        
};


#ifdef __KERNEL__

#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,17))
#define kill_proc_info_as_uid(sig, info, pid, uid, euid)    \
    kill_proc_info_as_uid(sig, info, pid, uid, euid)
  
#elif (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,18))
#define kill_proc_info_as_uid(sig, info, pid, uid, euid)    \
    kill_proc_info_as_uid(sig, info, pid, uid, euid, 0)
  
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19))
#define kill_proc_info_as_uid(sig, info, pid, uid, euid)    \
    kill_pid_info_as_uid(sig, info, pid, uid, euid, 0)
#endif

#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))

enum {
    false   = 0,
    true    = 1
};

typedef _Bool bool;
#endif

typedef unsigned long uintptr_t;

typedef long intptr_t;

#define ker_malloc(m) kmalloc(m, GFP_KERNEL)

struct spin_locked_list {
    struct list_head    list;           
    rtnrt_lock_t        lock;           
};


#define SPIN_LOCKED_LIST(name)                                              \
    struct spin_locked_list name = {                                        \
        .list       = LIST_HEAD_INIT(name.list),                            \
        .lock       = RTNRT_LOCK_UNLOCKED(name.lock)                        \
    }


struct rwsema_locked_list
{
    struct list_head    list;           
    struct rw_semaphore lock;           
};

#define RWSEMA_LOCKED_LIST(name)                                            \
    struct rwsema_locked_list name = {                                      \
        .list       = LIST_HEAD_INIT(name.list),                            \
        .lock       = __RWSEM_INITIALIZER(name.lock)                        \
    };

#define is_between_incl(value, a, b)                                        \
    (((value) >= (a)) && ((value) <= (b)))

#define is_between_excl(value, a, b)                                        \
    (((value) > (a)) && ((value) < (b)))

static inline int most_kill(int signo, struct task_struct* p, int data)
{
    struct siginfo sinfo;
#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18))
    pid_t pid;
    pid = p->pid;
#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19))
    struct pid *pid;
    pid = task_pid(p);
#endif
    sinfo.si_signo = signo;
    sinfo.si_errno = 0;
    sinfo.si_code  = SI_MESGQ;
    sinfo.si_addr  = 0;
    sinfo.si_value.sival_int = data;

    /* send the signal */
    return kill_proc_info_as_uid(signo, &sinfo, pid, 0, 0);
}


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

#define assert(expression)                                                  \
       do {                                                                 \
           if (!(expression)) {                                             \
               rtnrt_err("Assertion \"%s\" failed: file \"%s\", line %d\n", \
                       #expression, __FILE__, __LINE__);                    \
           }                                                                \
       } while (0)
#else
#define assert(expression)                                                  \
       do { } while (0)
#endif

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

#define return_if_fails_dbg(expression)                                     \
        do {                                                                \
            if (!(expression)) {                                            \
                rtnrt_err("\"%s\" failed: file \"%s\", line %d\n",          \
                       #expression, __FILE__, __LINE__);                    \
                return;                                                     \
            }                                                               \
        } while (0)
#else
#define return_if_fails_dbg(expression)                                     \
        do { } while (0)
#endif

#if defined(REG_ACCESS_DEBUG) || defined(DOXYGEN)

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

#if defined(IOCTL_DEBUG) || defined(DOXYGEN)

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

#if defined(DEVFUNC_DEBUG) || defined(DOXYGEN)

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

#if defined(IRQ_DEBUG) || defined(DOXYGEN)

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

#if defined(RT_IRQ_DEBUG) || defined(DOXYGEN)

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

#if defined(TXBUF_DEBUG) || defined(DOXYGEN)

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

#if defined(RXBUF_DEBUG) || defined(DOXYGEN)

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

#if defined(SYNC_DEBUG) || defined(DOXYGEN)

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

#if defined(NETS_DEBUG) || defined(DOXYGEN)

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

#if defined(ALSA_DEBUG) || defined(DOXYGEN)

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

#if defined(MEASURING_SCHED) || defined(MEASURING_PCI) || defined(DOXYGEN)

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

#ifdef DEBUG
#   define return_value_if_fails_dbg(expression, value)                     \
       do {                                                                 \
           if (!(expression)) {                                             \
               rtnrt_err("\"%s\" failed: file \"%s\", line %d\n",           \
                      #expression, __FILE__, __LINE__);                     \
               return value;                                                \
           }                                                                \
       } while (0)
#else
#   define return_value_if_fails_dbg(expression, value)                     \
        do { } while (0)
#endif


#define return_if_fails(expression)                                         \
    do {                                                                    \
        if (!(expression)) {                                                \
            return;                                                         \
        }                                                                   \
    } while (0)


#define return_value_if_fails(expression, value)                            \
      do {                                                                  \
          if (!(expression)) {                                              \
              return value;                                                 \
          }                                                                 \
      } while (0)

static inline void swap_bytes(u8 *b, int length)
{
    u8 c;

        length -= length % 2;
        for (; length; b += 2, length -= 2) {
            c = *b;
                *b = *(b + 1);
                *(b + 1) = c;
        }
}


#endif /* __KERNEL__ */

#endif /* MOST_COMMON_H */


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

---