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
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
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
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
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
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
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
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
00490
00491
00534 #ifdef DOXYGEN_CPP
00535 #define RTDM_EXECUTE_ATOMICALLY(code_block) \
00536 { \
00537 <ENTER_ATOMIC_SECTION> \
00538 code_block; \
00539 <LEAVE_ATOMIC_SECTION> \
00540 }
00541 #else
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
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
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
00783
00784
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
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
00830
00831
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
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
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
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
00898
00899
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
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
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
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
01001
01002
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
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
01024 #define rtdm_event_select_bind(e, s, t, b) ({ -EBADF; })
01025 #endif
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
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
01049
01050
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
01065 #define rtdm_sem_select_bind(s, se, t, b) ({ -EBADF; })
01066 #endif
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
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
01080
01081
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
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
01110
01111
01112
01113 #define rtdm_printk(format, ...) printk(format, ##__VA_ARGS__)
01114
01115 #ifndef DOXYGEN_CPP
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
01190
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
01201
01202 static inline int rtdm_in_rt_context(void)
01203 {
01204 return (rthal_current_domain != rthal_root_domain);
01205 }
01206 #endif
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