include/rtdm/rtdm_driver.h

Go to the documentation of this file.
00001 
00025 #ifndef _RTDM_DRIVER_H
00026 #define _RTDM_DRIVER_H
00027 
00028 #ifndef __KERNEL__
00029 #error This header is for kernel space usage only. \
00030        You are likely looking for rtdm/rtdm.h...
00031 #endif /* !__KERNEL__ */
00032 
00033 #include <asm/atomic.h>
00034 #include <linux/list.h>
00035 
00036 #include <nucleus/xenomai.h>
00037 #include <nucleus/core.h>
00038 #include <nucleus/heap.h>
00039 #include <nucleus/pod.h>
00040 #include <nucleus/synch.h>
00041 #include <nucleus/select.h>
00042 #include <rtdm/rtdm.h>
00043 
00044 /* debug support */
00045 #include <nucleus/assert.h>
00046 
00047 #ifndef CONFIG_XENO_OPT_DEBUG_RTDM
00048 #define CONFIG_XENO_OPT_DEBUG_RTDM      0
00049 #endif
00050 
00051 struct rtdm_dev_context;
00052 
00065 #define RTDM_EXCLUSIVE                  0x0001
00066 
00068 #define RTDM_NAMED_DEVICE               0x0010
00069 
00072 #define RTDM_PROTOCOL_DEVICE            0x0020
00073 
00075 #define RTDM_DEVICE_TYPE_MASK           0x00F0
00076 
00085 #define RTDM_CREATED_IN_NRT             0
00086 
00088 #define RTDM_CLOSING                    1
00089 
00091 #define RTDM_USER_CONTEXT_FLAG          8  /* first user-definable flag */
00092 
00101 #define RTDM_DEVICE_STRUCT_VER          4
00102 
00104 #define RTDM_CONTEXT_STRUCT_VER         3
00105 
00107 #define RTDM_SECURE_DEVICE              0x80000000
00108 
00110 #define RTDM_DRIVER_VER(major, minor, patch) \
00111         (((major & 0xFF) << 16) | ((minor & 0xFF) << 8) | (patch & 0xFF))
00112 
00114 #define RTDM_DRIVER_MAJOR_VER(ver)      (((ver) >> 16) & 0xFF)
00115 
00117 #define RTDM_DRIVER_MINOR_VER(ver)      (((ver) >> 8) & 0xFF)
00118 
00120 #define RTDM_DRIVER_PATCH_VER(ver)      ((ver) & 0xFF)
00121 
00140 typedef int (*rtdm_open_handler_t)(struct rtdm_dev_context *context,
00141                                    rtdm_user_info_t *user_info, int oflag);
00142 
00155 typedef int (*rtdm_socket_handler_t)(struct rtdm_dev_context *context,
00156                                      rtdm_user_info_t *user_info, int protocol);
00157 
00169 typedef int (*rtdm_close_handler_t)(struct rtdm_dev_context *context,
00170                                     rtdm_user_info_t *user_info);
00171 
00185 typedef int (*rtdm_ioctl_handler_t)(struct rtdm_dev_context *context,
00186                                     rtdm_user_info_t *user_info,
00187                                     unsigned int request, void __user *arg);
00188 
00202 typedef ssize_t (*rtdm_read_handler_t)(struct rtdm_dev_context *context,
00203                                        rtdm_user_info_t *user_info,
00204                                        void *buf, size_t nbyte);
00205 
00220 typedef ssize_t (*rtdm_write_handler_t)(struct rtdm_dev_context *context,
00221                                         rtdm_user_info_t *user_info,
00222                                         const void *buf, size_t nbyte);
00223 
00239 typedef ssize_t (*rtdm_recvmsg_handler_t)(struct rtdm_dev_context *context,
00240                                           rtdm_user_info_t *user_info,
00241                                           struct msghdr *msg, int flags);
00242 
00258 typedef ssize_t (*rtdm_sendmsg_handler_t)(struct rtdm_dev_context *context,
00259                                           rtdm_user_info_t *user_info,
00260                                           const struct msghdr *msg, int flags);
00263 typedef int (*rtdm_rt_handler_t)(struct rtdm_dev_context *context,
00264                                  rtdm_user_info_t *user_info, void *arg);
00265 
00266 typedef int (*rtdm_select_bind_handler_t)(struct rtdm_dev_context *context,
00267                                           struct xnselector *selector,
00268                                           unsigned type,
00269                                           unsigned index);
00273 struct rtdm_operations {
00277         rtdm_close_handler_t close_rt;
00279         rtdm_close_handler_t close_nrt;
00280 
00282         rtdm_ioctl_handler_t ioctl_rt;
00284         rtdm_ioctl_handler_t ioctl_nrt;
00290         rtdm_read_handler_t read_rt;
00292         rtdm_read_handler_t read_nrt;
00293 
00295         rtdm_write_handler_t write_rt;
00297         rtdm_write_handler_t write_nrt;
00303         rtdm_recvmsg_handler_t recvmsg_rt;
00305         rtdm_recvmsg_handler_t recvmsg_nrt;
00306 
00308         rtdm_sendmsg_handler_t sendmsg_rt;
00310         rtdm_sendmsg_handler_t sendmsg_nrt;
00313         rtdm_select_bind_handler_t select_bind;
00314 };
00315 
00316 struct rtdm_devctx_reserved {
00317         void *owner;
00318 };
00319 
00331 struct rtdm_dev_context {
00333         unsigned long context_flags;
00334 
00336         int fd;
00337 
00340         atomic_t close_lock_count;
00341 
00343         struct rtdm_operations *ops;
00344 
00346         struct rtdm_device *device;
00347 
00349         struct rtdm_devctx_reserved reserved;
00350 
00352         char dev_private[0];
00353 };
00354 
00355 struct rtdm_dev_reserved {
00356         struct list_head entry;
00357         atomic_t refcount;
00358         struct rtdm_dev_context *exclusive_context;
00359 };
00360 
00368 struct rtdm_device {
00371         int struct_version;
00372 
00374         int device_flags;
00376         size_t context_size;
00377 
00379         char device_name[RTDM_MAX_DEVNAME_LEN + 1];
00380 
00382         int protocol_family;
00384         int socket_type;
00385 
00388         rtdm_open_handler_t open_rt;
00391         rtdm_open_handler_t open_nrt;
00392 
00395         rtdm_socket_handler_t socket_rt;
00398         rtdm_socket_handler_t socket_nrt;
00399 
00401         struct rtdm_operations ops;
00402 
00404         int device_class;
00407         int device_sub_class;
00409         int profile_version;
00411         const char *driver_name;
00413         int driver_version;
00416         const char *peripheral_name;
00418         const char *provider_name;
00419 
00421         const char *proc_name;
00423         struct proc_dir_entry *proc_entry;
00424 
00426         int device_id;
00428         void *device_data;
00429 
00431         struct rtdm_dev_reserved reserved;
00432 };
00435 /* --- device registration --- */
00436 
00437 int rtdm_dev_register(struct rtdm_device *device);
00438 int rtdm_dev_unregister(struct rtdm_device *device, unsigned int poll_delay);
00439 
00440 /* --- inter-driver API --- */
00441 
00442 #define rtdm_open               rt_dev_open
00443 #define rtdm_socket             rt_dev_socket
00444 #define rtdm_close              rt_dev_close
00445 #define rtdm_ioctl              rt_dev_ioctl
00446 #define rtdm_read               rt_dev_read
00447 #define rtdm_write              rt_dev_write
00448 #define rtdm_recvmsg            rt_dev_recvmsg
00449 #define rtdm_recv               rt_dev_recv
00450 #define rtdm_recvfrom           rt_dev_recvfrom
00451 #define rtdm_sendmsg            rt_dev_sendmsg
00452 #define rtdm_send               rt_dev_send
00453 #define rtdm_sendto             rt_dev_sendto
00454 #define rtdm_bind               rt_dev_bind
00455 #define rtdm_listen             rt_dev_listen
00456 #define rtdm_accept             rt_dev_accept
00457 #define rtdm_getsockopt         rt_dev_getsockopt
00458 #define rtdm_setsockopt         rt_dev_setsockopt
00459 #define rtdm_getsockname        rt_dev_getsockname
00460 #define rtdm_getpeername        rt_dev_getpeername
00461 #define rtdm_shutdown           rt_dev_shutdown
00462 
00463 struct rtdm_dev_context *rtdm_context_get(int fd);
00464 
00465 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
00466 static inline void rtdm_context_lock(struct rtdm_dev_context *context)
00467 {
00468         atomic_inc(&context->close_lock_count);
00469 }
00470 
00471 static inline void rtdm_context_unlock(struct rtdm_dev_context *context)
00472 {
00473         atomic_dec(&context->close_lock_count);
00474 }
00475 
00476 /* --- clock services --- */
00477 struct xntbase;
00478 extern struct xntbase *rtdm_tbase;
00479 
00480 static inline nanosecs_abs_t rtdm_clock_read(void)
00481 {
00482         return xntbase_ticks2ns(rtdm_tbase, xntbase_get_time(rtdm_tbase));
00483 }
00484 
00485 static inline nanosecs_abs_t rtdm_clock_read_monotonic(void)
00486 {
00487         return xntbase_ticks2ns(rtdm_tbase, xntbase_get_jiffies(rtdm_tbase));
00488 }
00489 #endif /* !DOXYGEN_CPP */
00490 
00491 /* --- spin lock services --- */
00534 #ifdef DOXYGEN_CPP /* Beautify doxygen output */
00535 #define RTDM_EXECUTE_ATOMICALLY(code_block)     \
00536 {                                               \
00537         <ENTER_ATOMIC_SECTION>                  \
00538         code_block;                             \
00539         <LEAVE_ATOMIC_SECTION>                  \
00540 }
00541 #else /* This is how it really works */
00542 #define RTDM_EXECUTE_ATOMICALLY(code_block)     \
00543 {                                               \
00544         spl_t s;                                \
00545                                                 \
00546         xnlock_get_irqsave(&nklock, s);         \
00547         code_block;                             \
00548         xnlock_put_irqrestore(&nklock, s);      \
00549 }
00550 #endif
00551 
00561 #define RTDM_LOCK_UNLOCKED      RTHAL_SPIN_LOCK_UNLOCKED
00562 
00564 typedef rthal_spinlock_t rtdm_lock_t;
00565 
00567 typedef unsigned long rtdm_lockctx_t;
00568 
00584 #define rtdm_lock_init(lock)    rthal_spin_lock_init(lock)
00585 
00602 #define rtdm_lock_get(lock)     rthal_spin_lock(lock)
00603 
00620 #define rtdm_lock_put(lock)     rthal_spin_unlock(lock)
00621 
00639 #define rtdm_lock_get_irqsave(lock, context)    \
00640         rthal_spin_lock_irqsave(lock, context)
00641 
00659 #define rtdm_lock_put_irqrestore(lock, context) \
00660         rthal_spin_unlock_irqrestore(lock, context)
00661 
00678 #define rtdm_lock_irqsave(context)      \
00679         rthal_local_irq_save(context)
00680 
00697 #define rtdm_lock_irqrestore(context)   \
00698         rthal_local_irq_restore(context)
00699 
00703 /* --- Interrupt management services --- */
00709 typedef xnintr_t rtdm_irq_t;
00710 
00717 #define RTDM_IRQTYPE_SHARED             XN_ISR_SHARED
00718 
00720 #define RTDM_IRQTYPE_EDGE               XN_ISR_EDGE
00721 
00730 typedef int (*rtdm_irq_handler_t)(rtdm_irq_t *irq_handle);
00731 
00738 #define RTDM_IRQ_NONE                   XN_ISR_NONE
00739 
00740 #define RTDM_IRQ_HANDLED                XN_ISR_HANDLED
00741 
00760 #define rtdm_irq_get_arg(irq_handle, type)      ((type *)irq_handle->cookie)
00761 
00763 int rtdm_irq_request(rtdm_irq_t *irq_handle, unsigned int irq_no,
00764                      rtdm_irq_handler_t handler, unsigned long flags,
00765                      const char *device_name, void *arg);
00766 
00767 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
00768 static inline int rtdm_irq_free(rtdm_irq_t *irq_handle)
00769 {
00770         return xnintr_detach(irq_handle);
00771 }
00772 
00773 static inline int rtdm_irq_enable(rtdm_irq_t *irq_handle)
00774 {
00775         return xnintr_enable(irq_handle);
00776 }
00777 
00778 static inline int rtdm_irq_disable(rtdm_irq_t *irq_handle)
00779 {
00780         return xnintr_disable(irq_handle);
00781 }
00782 #endif /* !DOXYGEN_CPP */
00783 
00784 /* --- non-real-time signalling services --- */
00785 
00791 typedef unsigned rtdm_nrtsig_t;
00792 
00803 typedef void (*rtdm_nrtsig_handler_t)(rtdm_nrtsig_t nrt_sig, void *arg);
00806 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
00807 static inline int rtdm_nrtsig_init(rtdm_nrtsig_t *nrt_sig,
00808                                    rtdm_nrtsig_handler_t handler, void *arg)
00809 {
00810         *nrt_sig = rthal_alloc_virq();
00811 
00812         if (*nrt_sig == 0)
00813                 return -EAGAIN;
00814 
00815         rthal_virtualize_irq(rthal_root_domain, *nrt_sig, handler, arg, NULL,
00816                              IPIPE_HANDLE_MASK);
00817         return 0;
00818 }
00819 
00820 static inline void rtdm_nrtsig_destroy(rtdm_nrtsig_t *nrt_sig)
00821 {
00822         rthal_free_virq(*nrt_sig);
00823 }
00824 
00825 static inline void rtdm_nrtsig_pend(rtdm_nrtsig_t *nrt_sig)
00826 {
00827         rthal_trigger_irq(*nrt_sig);
00828 }
00829 #endif /* !DOXYGEN_CPP */
00830 
00831 /* --- timer services --- */
00832 
00838 typedef xntimer_t rtdm_timer_t;
00839 
00845 typedef void (*rtdm_timer_handler_t)(rtdm_timer_t *timer);
00846 
00852 enum rtdm_timer_mode {
00854         RTDM_TIMERMODE_RELATIVE = XN_RELATIVE,
00855 
00857         RTDM_TIMERMODE_ABSOLUTE = XN_ABSOLUTE,
00858 
00860         RTDM_TIMERMODE_REALTIME = XN_REALTIME
00861 };
00866 #ifndef DOXYGEN_CPP /* Avoid broken doxygen output */
00867 #define rtdm_timer_init(timer, handler, name)           \
00868 ({                                                      \
00869         xntimer_init((timer), rtdm_tbase, handler);     \
00870         xntimer_set_name((timer), (name));              \
00871         0;                                              \
00872 })
00873 #endif /* !DOXYGEN_CPP */
00874 
00875 void rtdm_timer_destroy(rtdm_timer_t *timer);
00876 
00877 int rtdm_timer_start(rtdm_timer_t *timer, nanosecs_abs_t expiry,
00878                      nanosecs_rel_t interval, enum rtdm_timer_mode mode);
00879 
00880 void rtdm_timer_stop(rtdm_timer_t *timer);
00881 
00882 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
00883 static inline int rtdm_timer_start_in_handler(rtdm_timer_t *timer,
00884                                               nanosecs_abs_t expiry,
00885                                               nanosecs_rel_t interval,
00886                                               enum rtdm_timer_mode mode)
00887 {
00888         return xntimer_start(timer, xntbase_ns2ticks_ceil(rtdm_tbase, expiry),
00889                              xntbase_ns2ticks_ceil(rtdm_tbase, interval),
00890                              (xntmode_t)mode);
00891 }
00892 
00893 static inline void rtdm_timer_stop_in_handler(rtdm_timer_t *timer)
00894 {
00895         xntimer_stop(timer);
00896 }
00897 #endif /* !DOXYGEN_CPP */
00898 
00899 /* --- task services --- */
00905 typedef xnthread_t rtdm_task_t;
00906 
00912 typedef void (*rtdm_task_proc_t)(void *arg);
00913 
00918 #define RTDM_TASK_LOWEST_PRIORITY       XNCORE_LOW_PRIO
00919 #define RTDM_TASK_HIGHEST_PRIORITY      XNCORE_HIGH_PRIO
00920 
00926 #define RTDM_TASK_RAISE_PRIORITY        (+1)
00927 #define RTDM_TASK_LOWER_PRIORITY        (-1)
00928 
00932 int rtdm_task_init(rtdm_task_t *task, const char *name,
00933                    rtdm_task_proc_t task_proc, void *arg,
00934                    int priority, nanosecs_rel_t period);
00935 int __rtdm_task_sleep(xnticks_t timeout, xntmode_t mode);
00936 void rtdm_task_busy_sleep(nanosecs_rel_t delay);
00937 
00938 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
00939 static inline void rtdm_task_destroy(rtdm_task_t *task)
00940 {
00941         xnpod_delete_thread(task);
00942 }
00943 
00944 void rtdm_task_join_nrt(rtdm_task_t *task, unsigned int poll_delay);
00945 
00946 static inline void rtdm_task_set_priority(rtdm_task_t *task, int priority)
00947 {
00948         xnpod_renice_thread(task, priority);
00949         xnpod_schedule();
00950 }
00951 
00952 static inline int rtdm_task_set_period(rtdm_task_t *task,
00953                                        nanosecs_rel_t period)
00954 {
00955         if (period < 0)
00956                 period = 0;
00957         return xnpod_set_thread_periodic(task, XN_INFINITE,
00958                                          xntbase_ns2ticks_ceil
00959                                          (xnthread_time_base(task), period));
00960 }
00961 
00962 static inline int rtdm_task_unblock(rtdm_task_t *task)
00963 {
00964         int res = xnpod_unblock_thread(task);
00965 
00966         xnpod_schedule();
00967         return res;
00968 }
00969 
00970 static inline rtdm_task_t *rtdm_task_current(void)
00971 {
00972         return xnpod_current_thread();
00973 }
00974 
00975 static inline int rtdm_task_wait_period(void)
00976 {
00977         XENO_ASSERT(RTDM, !xnpod_unblockable_p(), return -EPERM;);
00978         return xnpod_wait_thread_period(NULL);
00979 }
00980 
00981 static inline int rtdm_task_sleep(nanosecs_rel_t delay)
00982 {
00983         return __rtdm_task_sleep(delay, XN_RELATIVE);
00984 }
00985 
00986 static inline int
00987 rtdm_task_sleep_abs(nanosecs_abs_t wakeup_date, enum rtdm_timer_mode mode)
00988 {
00989         /* For the sake of a consistent API usage... */
00990         if (mode != RTDM_TIMERMODE_ABSOLUTE && mode != RTDM_TIMERMODE_REALTIME)
00991                 return -EINVAL;
00992         return __rtdm_task_sleep(wakeup_date, (xntmode_t)mode);
00993 }
00994 
00995 /* rtdm_task_sleep_abs shall be used instead */
00996 static inline int __deprecated rtdm_task_sleep_until(nanosecs_abs_t wakeup_time)
00997 {
00998         return __rtdm_task_sleep(wakeup_time, XN_REALTIME);
00999 }
01000 #endif /* !DOXYGEN_CPP */
01001 
01002 /* --- timeout sequences */
01003 
01004 typedef nanosecs_abs_t rtdm_toseq_t;
01005 
01006 void rtdm_toseq_init(rtdm_toseq_t *timeout_seq, nanosecs_rel_t timeout);
01007 
01008 /* --- event services --- */
01009 
01010 typedef struct {
01011         xnsynch_t synch_base;
01012         DECLARE_XNSELECT(select_block);
01013 } rtdm_event_t;
01014 
01015 #define RTDM_EVENT_PENDING              XNSYNCH_SPARE1
01016 
01017 void rtdm_event_init(rtdm_event_t *event, unsigned long pending);
01018 #ifdef CONFIG_XENO_OPT_RTDM_SELECT
01019 int rtdm_event_select_bind(rtdm_event_t *event,
01020                            struct xnselector *selector,
01021                            unsigned type,
01022                            unsigned bit_index);
01023 #else /* !CONFIG_XENO_OPT_RTDM_SELECT */
01024 #define rtdm_event_select_bind(e, s, t, b) ({ -EBADF; })
01025 #endif /* !CONFIG_XENO_OPT_RTDM_SELECT */
01026 int rtdm_event_wait(rtdm_event_t *event);
01027 int rtdm_event_timedwait(rtdm_event_t *event, nanosecs_rel_t timeout,
01028                          rtdm_toseq_t *timeout_seq);
01029 void rtdm_event_signal(rtdm_event_t *event);
01030 
01031 void rtdm_event_clear(rtdm_event_t *event);
01032 
01033 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
01034 void __rtdm_synch_flush(xnsynch_t *synch, unsigned long reason);
01035 
01036 static inline void rtdm_event_pulse(rtdm_event_t *event)
01037 {
01038         trace_mark(xn_rtdm_event_pulse, "event %p", event);
01039         __rtdm_synch_flush(&event->synch_base, 0);
01040 }
01041 
01042 static inline void rtdm_event_destroy(rtdm_event_t *event)
01043 {
01044         trace_mark(xn_rtdm_event_destroy, "event %p", event);
01045         __rtdm_synch_flush(&event->synch_base, XNRMID);
01046         xnselect_destroy(&event->select_block);
01047 }
01048 #endif /* !DOXYGEN_CPP */
01049 
01050 /* --- semaphore services --- */
01051 
01052 typedef struct {
01053         unsigned long value;
01054         xnsynch_t synch_base;
01055         DECLARE_XNSELECT(select_block);
01056 } rtdm_sem_t;
01057 
01058 void rtdm_sem_init(rtdm_sem_t *sem, unsigned long value);
01059 #ifdef CONFIG_XENO_OPT_RTDM_SELECT
01060 int rtdm_sem_select_bind(rtdm_sem_t *sem,
01061                          struct xnselector *selector,
01062                          unsigned type,
01063                          unsigned bit_index);
01064 #else /* !CONFIG_XENO_OPT_RTDM_SELECT */
01065 #define rtdm_sem_select_bind(s, se, t, b) ({ -EBADF; })
01066 #endif /* !CONFIG_XENO_OPT_RTDM_SELECT */
01067 int rtdm_sem_down(rtdm_sem_t *sem);
01068 int rtdm_sem_timeddown(rtdm_sem_t *sem, nanosecs_rel_t timeout,
01069                        rtdm_toseq_t *timeout_seq);
01070 void rtdm_sem_up(rtdm_sem_t *sem);
01071 
01072 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
01073 static inline void rtdm_sem_destroy(rtdm_sem_t *sem)
01074 {
01075         trace_mark(xn_rtdm_sem_destroy, "sem %p", sem);
01076         __rtdm_synch_flush(&sem->synch_base, XNRMID);
01077         xnselect_destroy(&sem->select_block);
01078 }
01079 #endif /* !DOXYGEN_CPP */
01080 
01081 /* --- mutex services --- */
01082 
01083 typedef struct {
01084         xnsynch_t synch_base;
01085 } rtdm_mutex_t;
01086 
01087 void rtdm_mutex_init(rtdm_mutex_t *mutex);
01088 int rtdm_mutex_lock(rtdm_mutex_t *mutex);
01089 int rtdm_mutex_timedlock(rtdm_mutex_t *mutex, nanosecs_rel_t timeout,
01090                          rtdm_toseq_t *timeout_seq);
01091 
01092 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
01093 static inline void rtdm_mutex_unlock(rtdm_mutex_t *mutex)
01094 {
01095         XENO_ASSERT(RTDM, !xnpod_asynch_p(), return;);
01096 
01097         trace_mark(xn_rtdm_mutex_unlock, "mutex %p", mutex);
01098 
01099         if (unlikely(xnsynch_wakeup_one_sleeper(&mutex->synch_base) != NULL))
01100                 xnpod_schedule();
01101 }
01102 
01103 static inline void rtdm_mutex_destroy(rtdm_mutex_t *mutex)
01104 {
01105         trace_mark(xn_rtdm_mutex_destroy, "mutex %p", mutex);
01106 
01107         __rtdm_synch_flush(&mutex->synch_base, XNRMID);
01108 }
01109 #endif /* !DOXYGEN_CPP */
01110 
01111 /* --- utility functions --- */
01112 
01113 #define rtdm_printk(format, ...)        printk(format, ##__VA_ARGS__)
01114 
01115 #ifndef DOXYGEN_CPP /* Avoid static inline tags for RTDM in doxygen */
01116 static inline void *rtdm_malloc(size_t size)
01117 {
01118         return xnmalloc(size);
01119 }
01120 
01121 static inline void rtdm_free(void *ptr)
01122 {
01123         xnfree(ptr);
01124 }
01125 
01126 #ifdef CONFIG_XENO_OPT_PERVASIVE
01127 int rtdm_mmap_to_user(rtdm_user_info_t *user_info,
01128                       void *src_addr, size_t len,
01129                       int prot, void **pptr,
01130                       struct vm_operations_struct *vm_ops,
01131                       void *vm_private_data);
01132 int rtdm_iomap_to_user(rtdm_user_info_t *user_info,
01133                        unsigned long src_addr, size_t len,
01134                        int prot, void **pptr,
01135                        struct vm_operations_struct *vm_ops,
01136                        void *vm_private_data);
01137 int rtdm_munmap(rtdm_user_info_t *user_info, void *ptr, size_t len);
01138 
01139 static inline int rtdm_read_user_ok(rtdm_user_info_t *user_info,
01140                                     const void __user *ptr, size_t size)
01141 {
01142         return __xn_access_ok(user_info, VERIFY_READ, ptr, size);
01143 }
01144 
01145 static inline int rtdm_rw_user_ok(rtdm_user_info_t *user_info,
01146                                   const void __user *ptr, size_t size)
01147 {
01148         return __xn_access_ok(user_info, VERIFY_WRITE, ptr, size);
01149 }
01150 
01151 static inline int rtdm_copy_from_user(rtdm_user_info_t *user_info,
01152                                       void *dst, const void __user *src,
01153                                       size_t size)
01154 {
01155         return __xn_copy_from_user(user_info, dst, src, size) ? -EFAULT : 0;
01156 }
01157 
01158 static inline int rtdm_safe_copy_from_user(rtdm_user_info_t *user_info,
01159                                            void *dst, const void __user *src,
01160                                            size_t size)
01161 {
01162         return (!__xn_access_ok(user_info, VERIFY_READ, src, size) ||
01163                 __xn_copy_from_user(user_info, dst, src, size)) ? -EFAULT : 0;
01164 }
01165 
01166 static inline int rtdm_copy_to_user(rtdm_user_info_t *user_info,
01167                                     void __user *dst, const void *src,
01168                                     size_t size)
01169 {
01170         return __xn_copy_to_user(user_info, dst, src, size) ? -EFAULT : 0;
01171 }
01172 
01173 static inline int rtdm_safe_copy_to_user(rtdm_user_info_t *user_info,
01174                                          void __user *dst, const void *src,
01175                                          size_t size)
01176 {
01177         return (!__xn_access_ok(user_info, VERIFY_WRITE, dst, size) ||
01178                 __xn_copy_to_user(user_info, dst, src, size)) ? -EFAULT : 0;
01179 }
01180 
01181 static inline int rtdm_strncpy_from_user(rtdm_user_info_t *user_info,
01182                                          char *dst,
01183                                          const char __user *src, size_t count)
01184 {
01185         if (unlikely(!__xn_access_ok(user_info, VERIFY_READ, src, 1)))
01186                 return -EFAULT;
01187         return __xn_strncpy_from_user(user_info, dst, src, count);
01188 }
01189 #else /* !CONFIG_XENO_OPT_PERVASIVE */
01190 /* Define void user<->kernel services that simply fail */
01191 #define rtdm_mmap_to_user(...)          ({ -ENOSYS; })
01192 #define rtdm_munmap(...)                ({ -ENOSYS; })
01193 #define rtdm_read_user_ok(...)          ({ 0; })
01194 #define rtdm_rw_user_ok(...)            ({ 0; })
01195 #define rtdm_copy_from_user(...)        ({ -ENOSYS; })
01196 #define rtdm_safe_copy_from_user(...)   ({ -ENOSYS; })
01197 #define rtdm_copy_to_user(...)          ({ -ENOSYS; })
01198 #define rtdm_safe_copy_to_user(...)     ({ -ENOSYS; })
01199 #define rtdm_strncpy_from_user(...)     ({ -ENOSYS; })
01200 #endif /* CONFIG_XENO_OPT_PERVASIVE */
01201 
01202 static inline int rtdm_in_rt_context(void)
01203 {
01204         return (rthal_current_domain != rthal_root_domain);
01205 }
01206 #endif /* !DOXYGEN_CPP */
01207 
01208 int rtdm_exec_in_rt(struct rtdm_dev_context *context,
01209                     rtdm_user_info_t *user_info, void *arg,
01210                     rtdm_rt_handler_t handler);
01211 
01212 #endif /* _RTDM_DRIVER_H */

Generated on Mon Mar 24 18:02:40 2008 for Xenomai API by  doxygen 1.5.3