rtai_fifos.h

Go to the documentation of this file.

#ifndef _RTAI_FIFOS_H
#define _RTAI_FIFOS_H

#include <rtai_types.h>

#define MAX_FIFOS 64

#define RTAI_FIFOS_MAJOR 150

#define RESET                   1
#define RESIZE                  2
#define RTF_SUSPEND_TIMED       3
#define OPEN_SIZED              4
#define READ_ALL_AT_ONCE        5
#define READ_TIMED              6
#define WRITE_TIMED             7
#define RTF_SEM_INIT            8
#define RTF_SEM_WAIT            9
#define RTF_SEM_TRYWAIT         10
#define RTF_SEM_TIMED_WAIT      11
#define RTF_SEM_POST            12
#define RTF_SEM_DESTROY         13
#define SET_ASYNC_SIG           14
#define EAVESDROP               19
#define OVRWRITE                20
#define READ_IF                 21
#define WRITE_IF                22
#define RTF_NAMED_CREATE        23

#define RTF_GET_N_FIFOS         15
#define RTF_GET_FIFO_INFO       16
#define RTF_CREATE_NAMED        17
#define RTF_NAME_LOOKUP         18

#define RTF_NAMELEN 15

struct rt_fifo_info_struct{
        unsigned int fifo_number;
        unsigned int size;
        unsigned int opncnt;
        char name[RTF_NAMELEN+1];
};

struct rt_fifo_get_info_struct{
        unsigned int fifo;
        unsigned int n;
        struct rt_fifo_info_struct *ptr;
};

#define  FUN_FIFOS_LXRT_INDX 10

#define _CREATE         0
#define _DESTROY        1
#define _PUT            2
#define _GET            3
#define _RESET          4
#define _RESIZE         5
#define _SEM_INIT       6
#define _SEM_DESTRY     7
#define _SEM_POST       8
#define _SEM_TRY        9
#define _CREATE_NAMED  10
#define _GETBY_NAME    11
#define _OVERWRITE     12
#define _PUT_IF        13
#define _GET_IF        14
#define _NAMED_CREATE  15

#ifdef __KERNEL__

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

int __rtai_fifos_init(void);

void __rtai_fifos_exit(void);

int rtf_init(void);

/* Attach a handler to an RT-FIFO.
 *
 * Allow function handler to be called when a user process reads or writes to 
 * the FIFO. When the function is called, it is passed the fifo number as the 
 * argument.
 */

int rtf_create_handler(unsigned int fifo,       /* RT-FIFO */
                       int (*handler)(unsigned int fifo)        /* function to be called */);


#define X_FIFO_HANDLER(handler) ((int (*)(unsigned int))(handler))

/* Create an RT-FIFO.
 * 
 * An RT-FIFO fifo is created with initial size of size.
 * Return value: On success, 0 is returned. On error, -1 is returned.
 */
#undef rtf_create
int rtf_create(unsigned int fifo, int size);

/* Create an RT-FIFO with a name and size.
 *
 * An RT-FIFO is created with a name of name, it will be allocated
 * the first unused minor number and will have a user assigned size.
 * Return value: On success, the allocated minor number is returned.
 *               On error, -errno is returned.
 */

int rtf_named_create(const char *name, int size);

/* Create an RT-FIFO with a name.
 *
 * An RT-FIFO is created with a name of name, it will be allocated
 * the first unused minor number and will have a default size.
 * Return value: On success, the allocated minor number is returned. 
 *               On error, -errno is returned.
 */

int rtf_create_named(const char *name);

/* Look up a named RT-FIFO.
 *
 * Find the RT-FIFO with the name name.
 * Return value: On success, the minor number is returned. 
 *               On error, -errno is returned.
 */

int rtf_getfifobyname(const char *name);

/* Reset an RT-FIFO.
 * 
 * An RT-FIFO fifo is reset by setting its buffer pointers to zero, so
 * that any existing data is discarded and the fifo started anew like at its
 * creation.
 */

int rtf_reset(unsigned int fifo);

/* destroy an RT-FIFO.
 * 
 * Return value: On success, 0 is returned.
 */

int rtf_destroy(unsigned int fifo);


/* Resize an RT-FIFO.
 * 
 * Return value: size is returned on success. On error, a negative value
 * is returned.
 */

int rtf_resize(unsigned int minor, int size);


/* Write to an RT-FIFO.
 *
 * Try to write count bytes to an FIFO. Returns the number of bytes written.
 */

int rtf_put(unsigned int fifo,  /* RT-FIFO */
            void * buf,         /* buffer address */
            int count           /* number of bytes to write */);



/* Write to an RT-FIFO, over writing if there is not enough space.
 *
 * Try to write count bytes to an FIFO. Returns 0.
 */

int rtf_ovrwr_put(unsigned int fifo,    /* RT-FIFO */
                  void * buf,           /* buffer address */
                  int count             /* number of bytes to write */);



/* Write atomically to an RT-FIFO.
 *
 * Try to write count bytes in block to an FIFO. Returns the number of bytes
 * written.
 */

extern int rtf_put_if (unsigned int fifo,       /* RT-FIFO */
                void * buf,                     /* buffer address */
                int count                       /* number of bytes to write */);

/* Read from an RT-FIFO.
 *
 * Try to read count bytes from a FIFO. Returns the number of bytes read.
 */

int rtf_get(unsigned int fifo,  /* RT-FIFO */
            void * buf,                 /* buffer address */
            int count           /* number of bytes to read */);


/* Atomically read from an RT-FIFO.
 *
 * Try to read count bytes in a block from an FIFO. Returns the number of bytes read.
 */

int rtf_get_if(unsigned int fifo,       /* RT-FIFO */
            void * buf,                 /* buffer address */
            int count           /* number of bytes to read */);


/* 
 * Preview the an RT-FIFO content.
 */

int rtf_evdrp(unsigned int fifo,        /* RT-FIFO */
              void * buf,               /* buffer address */
              int count         /* number of bytes to read */);

/* Open an RT-FIFO semaphore.
 *
 */

int rtf_sem_init(unsigned int fifo,     /* RT-FIFO */
                 int value                      /* initial semaphore value */);


/* Post to an RT-FIFO semaphore.
 *
 */

int rtf_sem_post(unsigned int fifo      /* RT-FIFO */);


/* Try to acquire an RT-FIFO semaphore.
 *
 */

int rtf_sem_trywait(unsigned int fifo   /* RT-FIFO */);


/* Destroy an RT-FIFO semaphore.
 *
 */

int rtf_sem_destroy(unsigned int fifo   /* RT-FIFO */);

#define rtf_sem_delete rtf_sem_destroy

/* Just for compatibility with earlier rtai_fifos releases. No more bh and user
buffers. Fifos are now awakened immediately and buffers > 128K are vmalloced */

#define rtf_create_using_bh(fifo, size, bh_list) rtf_create(fifo, size)
#define rtf_create_using_bh_and_usr_buf(fifo, buf, size, bh_list) rtf_create(fifo, size)
#define rtf_destroy_using_usr_buf(fifo) rtf_destroy(fifo)

#ifdef __cplusplus
}
#endif /* __cplusplus */

#else  /* !__KERNEL__ */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <rtai_lxrt.h>

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

RTAI_PROTO(int, rtf_create,(unsigned int fifo, int size))
{
        struct { unsigned int fifo, size; } arg = { fifo, size }; 
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _CREATE, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_destroy,(unsigned int fifo))
{
        struct { unsigned int fifo; } arg = { fifo };
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _DESTROY, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_put,(unsigned int fifo, const void *buf, int count))
{
        char lbuf[count];
        struct { unsigned int fifo; void *buf; int count; } arg = { fifo, lbuf, count };
        memcpy(lbuf, buf, count);
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _PUT, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_put_if,(unsigned int fifo, const void *buf, int count))
{
        char lbuf[count];
        struct { unsigned int fifo; void *buf; int count; } arg = { fifo, lbuf, count };
        memcpy(lbuf, buf, count);
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _PUT_IF, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_get,(unsigned int fifo, void *buf, int count))
{
        int retval;
        char lbuf[count];
        struct { unsigned int fifo; void *buf; int count; } arg = { fifo, lbuf, count };
        retval = rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _GET, &arg).i[LOW];
        if (retval > 0) {
                memcpy(buf, lbuf, retval);
        }
        return retval;
}

RTAI_PROTO(int, rtf_get_if,(unsigned int fifo, void *buf, int count))
{
        int retval;
        char lbuf[count];
        struct { unsigned int fifo; void *buf; int count; } arg = { fifo, lbuf, count };
        retval = rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _GET_IF, &arg).i[LOW];
        if (retval > 0) {
                memcpy(buf, lbuf, retval);
        }
        return retval;
}

RTAI_PROTO(int, rtf_reset_lxrt,(unsigned int fifo))
{
        struct { unsigned int fifo; } arg = { fifo };
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _RESET, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_resize_lxrt,(unsigned int fifo, int size))
{
        struct { unsigned int fifo, size; } arg = { fifo, size }; 
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _RESIZE, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_sem_init_lxrt,(unsigned int fifo, int value))
{
        struct { unsigned int fifo, value; } arg = { fifo, value }; 
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_INIT, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_sem_post_lxrt,(unsigned int fifo))
{
        struct { unsigned int fifo; } arg = { fifo }; 
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_POST, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_sem_trywait_lxrt,(unsigned int fifo))
{
        struct { unsigned int fifo; } arg = { fifo }; 
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_TRY, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_sem_destroy_lxrt,(unsigned int fifo))
{
        struct { unsigned int fifo; } arg = { fifo }; 
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _SEM_DESTRY, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_named_create_lxrt,(const char *name, int size))
{
        int len;
        char lname[len = strlen(name)];
        struct { char * name; int size; } arg = { lname, size };
        strncpy(lname, name, len);
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _NAMED_CREATE, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_create_named_lxrt,(const char *name))
{
        int len;
        char lname[len = strlen(name)];
        struct { char * name; } arg = { lname };
        strncpy(lname, name, len);
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _CREATE_NAMED, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_getfifobyname_lxrt,(const char *name))
{
        int len;
        char lname[len = strlen(name)];
        struct { char * name; } arg = { lname };
        strncpy(lname, name, len);
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _GETBY_NAME, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_ovrwr_put,(unsigned int fifo, const void *buf, int count))
{
        char lbuf[count];
        struct { unsigned int fifo; void *buf; int count; } arg = { fifo, lbuf, count };
        memcpy(lbuf, buf, count);
        return rtai_lxrt(FUN_FIFOS_LXRT_INDX, SIZARG, _OVERWRITE, &arg).i[LOW];
}

RTAI_PROTO(int, rtf_reset,(int fd))
{
        int ret = ioctl(fd, RESET);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_resize,(int fd, int size))
{
        int ret = ioctl(fd, RESIZE, size);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_suspend_timed,(int fd, int ms_delay))
{
        int ret = ioctl(fd, RTF_SUSPEND_TIMED, ms_delay);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_open_sized,(const char *dev, int perm, int size))
{
        int fd;

        if ((fd = open(dev, perm)) < 0) { 
                return -errno;
        }
        if (ioctl(fd, RESIZE, size) < 0) {
                close(fd);
                return -errno;
        }
        return fd; 
}

RTAI_PROTO(int, rtf_evdrp,(int fd, void *buf, int count))
{
        struct { void *buf; int count; } args = { buf, count };
        int ret = ioctl(fd, EAVESDROP, &args);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_read_all_at_once,(int fd, void *buf, int count))
{
        struct { void *buf; int count; } args = { buf, count };
        int ret = ioctl(fd, READ_ALL_AT_ONCE, &args);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_read_timed,(int fd, void *buf, int count, int ms_delay))
{
        struct { void *buf; int count, delay; } args = { buf, count, ms_delay };
        int ret = ioctl(fd, READ_TIMED, &args);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_read_if,(int fd, void *buf, int count))
{
        struct { void *buf; int count; } args = { buf, count };
        int ret = ioctl(fd, READ_IF, &args);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_write_timed,(int fd, void *buf, int count, int ms_delay))
{
        struct { void *buf; int count, delay; } args = { buf, count, ms_delay };
        int ret = ioctl(fd, WRITE_TIMED, &args);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_overwrite,(int fd, void *buf, int count))
{
        struct { void *buf; int count; } args = { buf, count };
        int ret = ioctl(fd, OVRWRITE, &args);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_write_if,(int fd, void *buf, int count))
{
        struct { void *buf; int count; } args = { buf, count };
        int ret = ioctl(fd, WRITE_IF, &args);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_sem_init,(int fd, int value))
{
        int ret = ioctl(fd, RTF_SEM_INIT, value);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_sem_wait,(int fd))
{
        int ret = ioctl(fd, RTF_SEM_WAIT);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_sem_trywait,(int fd))
{
        int ret = ioctl(fd, RTF_SEM_TRYWAIT);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_sem_timed_wait,(int fd, int ms_delay))
{
        int ret = ioctl(fd, RTF_SEM_TIMED_WAIT, ms_delay);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_sem_post,(int fd))
{
        int ret = ioctl(fd, RTF_SEM_POST);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_sem_destroy,(int fd))
{
        int ret = ioctl(fd, RTF_SEM_DESTROY);
        return ret < 0 ? -errno : ret;
}

RTAI_PROTO(int, rtf_set_async_sig,(int fd, int signum))
{
        int ret = ioctl(fd, SET_ASYNC_SIG, signum);
        return ret < 0 ? -errno : ret;
}

/*
 * Support for named FIFOS : Ian Soanes (ians@zentropix.com)
 * Based on ideas from Stuart Hughes and David Schleef
 */

RTAI_PROTO_ALWAYS_INLINE(char *, rtf_getfifobyminor,(int minor, char *buf, int len))
{
    snprintf(buf,len,CONFIG_RTAI_FIFOS_TEMPLATE,minor);
    return buf;
}

RTAI_PROTO(int, rtf_getfifobyname,(const char *name))
{
        int fd, minor;
        char nm[RTF_NAMELEN+1];

        if (strlen(name) > RTF_NAMELEN) {
                return -1;
        }
        if ((fd = open(rtf_getfifobyminor(0,nm,sizeof(nm)), O_RDONLY)) < 0) {
                return -errno;
        }
        strncpy(nm, name, RTF_NAMELEN+1);
        minor = ioctl(fd, RTF_NAME_LOOKUP, nm);
        close(fd);
        return minor < 0 ? -errno : minor;
}

RTAI_PROTO(int, rtf_named_create,(const char *name, int size))
{
        int fd, minor;
        char nm[RTF_NAMELEN+1];

        if (strlen(name) > RTF_NAMELEN) {
                return -1;
        }
        if ((fd = open(rtf_getfifobyminor(0,nm,sizeof(nm)), O_RDONLY)) < 0) {
                return -errno;
        }
        strncpy(nm, name, RTF_NAMELEN+1);
        minor = ioctl(fd, RTF_NAMED_CREATE, nm, size);
        close(fd);
        return minor < 0 ? -errno : minor;
}

RTAI_PROTO(int, rtf_create_named,(const char *name))
{
        int fd, minor;
        char nm[RTF_NAMELEN+1];

        if (strlen(name) > RTF_NAMELEN) {
                return -1;
        }
        if ((fd = open(rtf_getfifobyminor(0,nm,sizeof(nm)), O_RDONLY)) < 0) { 
                return -errno;
        }
        strncpy(nm, name, RTF_NAMELEN+1);
        minor = ioctl(fd, RTF_CREATE_NAMED, nm);
        close(fd);
        return minor < 0 ? -errno : minor;
}

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* __KERNEL__ */

#endif /* !_RTAI_FIFOS_H */

---