26 #ifndef _COBALT_RTDM_DRIVER_H
27 #define _COBALT_RTDM_DRIVER_H
29 #include <asm/atomic.h>
30 #include <linux/list.h>
31 #include <linux/module.h>
32 #include <linux/cdev.h>
33 #include <linux/wait.h>
34 #include <linux/notifier.h>
35 #include <xenomai/version.h>
36 #include <cobalt/kernel/heap.h>
37 #include <cobalt/kernel/sched.h>
38 #include <cobalt/kernel/intr.h>
39 #include <cobalt/kernel/synch.h>
40 #include <cobalt/kernel/select.h>
41 #include <cobalt/kernel/clock.h>
42 #include <cobalt/kernel/apc.h>
43 #include <cobalt/kernel/init.h>
44 #include <cobalt/kernel/ancillaries.h>
45 #include <cobalt/kernel/tree.h>
47 #include <rtdm/rtdm.h>
50 #include <cobalt/kernel/assert.h>
51 #include <trace/events/cobalt-rtdm.h>
53 #include <asm-generic/xenomai/pci_ids.h>
55 #include <asm/xenomai/syscall.h>
58 typedef struct xnselector rtdm_selector_t;
73 #define RTDM_EXCLUSIVE 0x0001
80 #define RTDM_FIXED_MINOR 0x0002
83 #define RTDM_NAMED_DEVICE 0x0010
87 #define RTDM_PROTOCOL_DEVICE 0x0020
90 #define RTDM_DEVICE_TYPE_MASK 0x00F0
93 #define RTDM_SECURE_DEVICE 0x80000000
97 #define RTDM_MAX_MINOR 4096
147 static inline struct rtdm_dev_context *rtdm_fd_to_context(
struct rtdm_fd *fd)
191 return rtdm_fd_owner(fd) != &cobalt_kernel_ppd;
204 return rtdm_fd_to_context(fd)->
device;
227 struct module *owner;
228 struct class *kdev_class;
294 struct notifier_block nb_statechange;
299 #define RTDM_CLASS_MAGIC 0x8284636c
319 #define RTDM_PROFILE_INFO(__name, __id, __subid, __version) \
321 .name = ( # __name ), \
322 .class_id = (__id), \
323 .subclass_id = (__subid), \
324 .version = (__version), \
325 .magic = ~RTDM_CLASS_MAGIC, \
326 .owner = THIS_MODULE, \
327 .kdev_class = NULL, \
384 struct class *kdev_class;
387 wait_queue_head_t putwq;
388 struct list_head openfd_list;
400 static inline struct device *rtdm_dev_to_kdev(
struct rtdm_device *device)
408 return xnclock_read_realtime(&nkclock);
413 return xnclock_read_monotonic(&nkclock);
458 #define cobalt_atomic_enter(__context) \
460 xnlock_get_irqsave(&nklock, (__context)); \
476 #define cobalt_atomic_leave(__context) \
479 xnlock_put_irqrestore(&nklock, (__context)); \
511 #define RTDM_EXECUTE_ATOMICALLY(code_block) \
513 <ENTER_ATOMIC_SECTION> \
515 <LEAVE_ATOMIC_SECTION> \
519 rtdm_execute_atomically(
void) { }
521 #define RTDM_EXECUTE_ATOMICALLY(code_block) \
525 rtdm_execute_atomically(); \
526 xnlock_get_irqsave(&nklock, __rtdm_s); \
530 xnlock_put_irqrestore(&nklock, __rtdm_s); \
544 #define RTDM_LOCK_UNLOCKED(__name) IPIPE_SPIN_LOCK_UNLOCKED
546 #define DEFINE_RTDM_LOCK(__name) \
547 rtdm_lock_t __name = RTDM_LOCK_UNLOCKED(__name)
564 raw_spin_lock_init(lock);
576 XENO_BUG_ON(COBALT, !
spltest());
590 raw_spin_unlock(lock);
602 #define rtdm_lock_get_irqsave(__lock, __context) \
603 ((__context) = __rtdm_lock_get_irqsave(__lock))
609 context = ipipe_test_and_stall_head();
627 raw_spin_unlock(lock);
629 ipipe_restore_head(context);
639 #define rtdm_lock_irqsave(__context) \
649 #define rtdm_lock_irqrestore(__context) \
656 struct rtdm_waitqueue {
659 typedef struct rtdm_waitqueue rtdm_waitqueue_t;
661 #define RTDM_WAITQUEUE_INITIALIZER(__name) { \
662 .wait = XNSYNCH_WAITQUEUE_INITIALIZER((__name).wait), \
665 #define DEFINE_RTDM_WAITQUEUE(__name) \
666 struct rtdm_waitqueue __name = RTDM_WAITQUEUE_INITIALIZER(__name)
668 #define DEFINE_RTDM_WAITQUEUE_ONSTACK(__name) \
669 DEFINE_RTDM_WAITQUEUE(__name)
673 *wq = (
struct rtdm_waitqueue)RTDM_WAITQUEUE_INITIALIZER(*wq);
681 static inline int __rtdm_dowait(
struct rtdm_waitqueue *wq,
696 static inline int __rtdm_timedwait(
struct rtdm_waitqueue *wq,
699 if (toseq && timeout > 0)
700 return __rtdm_dowait(wq, *toseq, XN_ABSOLUTE);
702 return __rtdm_dowait(wq, timeout, XN_RELATIVE);
705 #define rtdm_timedwait_condition_locked(__wq, __cond, __timeout, __toseq) \
708 while (__ret == 0 && !(__cond)) \
709 __ret = __rtdm_timedwait(__wq, __timeout, __toseq); \
713 #define rtdm_wait_condition_locked(__wq, __cond) \
716 while (__ret == 0 && !(__cond)) \
717 __ret = __rtdm_dowait(__wq, \
718 XN_INFINITE, XN_RELATIVE); \
722 #define rtdm_timedwait_condition(__wq, __cond, __timeout, __toseq) \
726 xnlock_get_irqsave(&nklock, __s); \
727 __ret = rtdm_timedwait_condition_locked(__wq, __cond, \
728 __timeout, __toseq); \
729 xnlock_put_irqrestore(&nklock, __s); \
733 #define rtdm_timedwait(__wq, __timeout, __toseq) \
734 __rtdm_timedwait(__wq, __timeout, __toseq)
736 #define rtdm_timedwait_locked(__wq, __timeout, __toseq) \
737 rtdm_timedwait(__wq, __timeout, __toseq)
739 #define rtdm_wait_condition(__wq, __cond) \
743 xnlock_get_irqsave(&nklock, __s); \
744 __ret = rtdm_wait_condition_locked(__wq, __cond); \
745 xnlock_put_irqrestore(&nklock, __s); \
749 #define rtdm_wait(__wq) \
750 __rtdm_dowait(__wq, XN_INFINITE, XN_RELATIVE)
752 #define rtdm_wait_locked(__wq) rtdm_wait(__wq)
754 #define rtdm_waitqueue_lock(__wq, __context) cobalt_atomic_enter(__context)
756 #define rtdm_waitqueue_unlock(__wq, __context) cobalt_atomic_leave(__context)
758 #define rtdm_waitqueue_signal(__wq) \
760 struct xnthread *__waiter; \
761 __waiter = xnsynch_wakeup_one_sleeper(&(__wq)->wait); \
766 #define __rtdm_waitqueue_flush(__wq, __reason) \
769 __ret = xnsynch_flush(&(__wq)->wait, __reason); \
771 __ret == XNSYNCH_RESCHED; \
774 #define rtdm_waitqueue_broadcast(__wq) \
775 __rtdm_waitqueue_flush(__wq, 0)
777 #define rtdm_waitqueue_flush(__wq) \
778 __rtdm_waitqueue_flush(__wq, XNBREAK)
780 #define rtdm_waitqueue_wakeup(__wq, __waiter) \
782 xnsynch_wakeup_this_sleeper(&(__wq)->wait, __waiter); \
786 #define rtdm_for_each_waiter(__pos, __wq) \
787 xnsynch_for_each_sleeper(__pos, &(__wq)->wait)
789 #define rtdm_for_each_waiter_safe(__pos, __tmp, __wq) \
790 xnsynch_for_each_sleeper_safe(__pos, __tmp, &(__wq)->wait)
802 typedef struct xnintr rtdm_irq_t;
810 #define RTDM_IRQTYPE_SHARED XN_IRQTYPE_SHARED
813 #define RTDM_IRQTYPE_EDGE XN_IRQTYPE_EDGE
831 #define RTDM_IRQ_NONE XN_IRQ_NONE
833 #define RTDM_IRQ_HANDLED XN_IRQ_HANDLED
835 #define RTDM_IRQ_DISABLE XN_IRQ_DISABLE
849 #define rtdm_irq_get_arg(irq_handle, type) ((type *)irq_handle->cookie)
854 const char *device_name,
void *arg);
859 if (!XENO_ASSERT(COBALT, xnsched_root_p()))
885 typedef struct rtdm_nrtsig rtdm_nrtsig_t;
910 nrt_sig->handler = handler;
916 nrt_sig->handler = NULL;
930 typedef struct xntimer rtdm_timer_t;
974 return xntimer_start(timer, expiry, interval, (xntmode_t)mode);
989 typedef struct xnthread rtdm_task_t;
1002 #define RTDM_TASK_LOWEST_PRIORITY 0
1003 #define RTDM_TASK_HIGHEST_PRIORITY 99
1010 #define RTDM_TASK_RAISE_PRIORITY (+1)
1011 #define RTDM_TASK_LOWER_PRIORITY (-1)
1019 int __rtdm_task_sleep(xnticks_t timeout, xntmode_t mode);
1036 static inline void __deprecated rtdm_task_join_nrt(rtdm_task_t *task,
1037 unsigned int poll_delay)
1044 union xnsched_policy_param param = { .rt = { .prio = priority } };
1059 if (start_date == 0)
1060 start_date = XN_INFINITE;
1085 if (!XENO_ASSERT(COBALT, !xnsched_unblockable_p()))
1092 return __rtdm_task_sleep(delay, XN_RELATIVE);
1101 return __rtdm_task_sleep(wakeup_date, (xntmode_t)mode);
1107 return __rtdm_task_sleep(wakeup_time, XN_REALTIME);
1110 #define rtdm_task_busy_wait(__condition, __spin_ns, __sleep_ns) \
1113 nanosecs_abs_t __end; \
1116 __end = rtdm_clock_read_monotonic() + __spin_ns; \
1120 if (rtdm_clock_read_monotonic() >= __end) \
1123 __ret = rtdm_task_sleep(__sleep_ns); \
1131 #define rtdm_wait_context xnthread_wait_context
1136 xnthread_complete_wait(wc);
1142 return xnthread_wait_complete_p(wc);
1147 xnthread_prepare_wait(wc);
1151 struct rtdm_wait_context *rtdm_wait_get_context(rtdm_task_t *task)
1153 return xnthread_get_wait_context(task);
1160 typedef struct rtdm_event {
1161 struct xnsynch synch_base;
1162 DECLARE_XNSELECT(select_block);
1165 #define RTDM_EVENT_PENDING XNSYNCH_SPARE1
1172 rtdm_toseq_t *timeout_seq);
1183 typedef struct rtdm_sem {
1184 unsigned long value;
1185 struct xnsynch synch_base;
1186 DECLARE_XNSELECT(select_block);
1194 rtdm_toseq_t *timeout_seq);
1201 typedef struct rtdm_mutex {
1202 struct xnsynch synch_base;
1209 rtdm_toseq_t *timeout_seq);
1215 #define rtdm_printk(format, ...) printk(format, ##__VA_ARGS__)
1217 #define rtdm_printk_ratelimited(fmt, ...) do { \
1218 if (xnclock_ratelimit()) \
1219 printk(fmt, ##__VA_ARGS__); \
1225 return xnmalloc(size);
1234 void *src_addr,
size_t len,
1235 int prot,
void **pptr,
1236 struct vm_operations_struct *vm_ops,
1237 void *vm_private_data);
1240 phys_addr_t src_addr,
size_t len,
1241 int prot,
void **pptr,
1242 struct vm_operations_struct *vm_ops,
1243 void *vm_private_data);
1254 const void __user *ptr,
size_t size)
1256 return access_rok(ptr, size);
1260 const void __user *ptr,
size_t size)
1262 return access_wok(ptr, size);
1266 void *dst,
const void __user *src,
1269 return __xn_copy_from_user(dst, src, size) ? -EFAULT : 0;
1273 void *dst,
const void __user *src,
1276 return cobalt_copy_from_user(dst, src, size);
1280 void __user *dst,
const void *src,
1283 return __xn_copy_to_user(dst, src, size) ? -EFAULT : 0;
1287 void __user *dst,
const void *src,
1290 return cobalt_copy_to_user(dst, src, size);
1295 const char __user *src,
size_t count)
1297 return cobalt_strncpy_from_user(dst, src, count);
1302 return realtime_core_enabled();
1307 if (!XENO_ASSERT(COBALT, !xnsched_interrupt_p()))
1311 return !xnsched_root_p();
1318 return (ipipe_current_domain != ipipe_root_domain);
1321 #define RTDM_IOV_FASTMAX 16
1323 int rtdm_get_iovec(
struct rtdm_fd *fd,
struct iovec **iov,
1324 const struct user_msghdr *msg,
1325 struct iovec *iov_fast);
1327 int rtdm_put_iovec(
struct rtdm_fd *fd,
struct iovec *iov,
1328 const struct user_msghdr *msg,
1329 struct iovec *iov_fast);
1332 void rtdm_drop_iovec(
struct iovec *iov,
struct iovec *iov_fast)
1334 if (iov != iov_fast)
1338 ssize_t rtdm_get_iov_flatlen(
struct iovec *iov,
int iovlen);
static bool rtdm_fd_is_user(struct rtdm_fd *fd)
Tell whether the passed file descriptor belongs to an application.
Definition: driver.h:189
static void * rtdm_fd_to_private(struct rtdm_fd *fd)
Locate the driver private area associated to a device context structure.
Definition: driver.h:161
static struct rtdm_device * rtdm_fd_device(struct rtdm_fd *fd)
Locate a device structure from a file descriptor.
Definition: driver.h:202
static struct rtdm_fd * rtdm_private_to_fd(void *dev_private)
Locate a device file descriptor structure from its driver private area.
Definition: driver.h:174
static int __attribute__((cold))
Test if a mutex structure contains a valid autoinitializer.
Definition: mutex.c:176
void xnintr_destroy(struct xnintr *intr)
Destroy an interrupt descriptor.
Definition: intr.c:808
void xnintr_enable(struct xnintr *intr)
Enable an interrupt line.
Definition: intr.c:924
void xnintr_disable(struct xnintr *intr)
Disable an interrupt line.
Definition: intr.c:955
#define splhigh(x)
Hard disable interrupts on the local processor, saving previous state.
Definition: lock.h:39
#define splexit(x)
Restore the saved hard interrupt state on the local processor.
Definition: lock.h:46
#define spltest()
Test hard interrupt state on the local processor.
Definition: lock.h:64
static int xnsched_run(void)
The rescheduling procedure.
Definition: sched.h:311
int __must_check xnsynch_sleep_on(struct xnsynch *synch, xnticks_t timeout, xntmode_t timeout_mode)
Sleep on an ownerless synchronization object.
Definition: synch.c:201
int xnsynch_destroy(struct xnsynch *synch)
Destroy a synchronization object.
Definition: synch.c:156
#define XNBREAK
Forcibly awaken from a wait state.
Definition: thread.h:69
#define XNTIMEO
Woken up due to a timeout condition.
Definition: thread.h:67
#define XNRMID
Pending on a removed resource.
Definition: thread.h:68
#define XNCANCELD
Cancellation request is pending.
Definition: thread.h:73
int xnthread_wait_period(unsigned long *overruns_r)
Wait for the next periodic release point.
Definition: thread.c:1398
static struct xnthread * xnthread_current(void)
Retrieve the current Cobalt core TCB.
Definition: thread.h:373
int xnthread_unblock(struct xnthread *thread)
Unblock a thread.
Definition: thread.c:1222
void xnthread_cancel(struct xnthread *thread)
Cancel a thread.
Definition: thread.c:1531
int xnthread_join(struct xnthread *thread, bool uninterruptible)
Join with a terminated thread.
Definition: thread.c:1660
int xnthread_set_periodic(struct xnthread *thread, xnticks_t idate, xntmode_t timeout_mode, xnticks_t period)
Make a thread periodic.
Definition: thread.c:1313
int xnthread_set_schedparam(struct xnthread *thread, struct xnsched_class *sched_class, const union xnsched_policy_param *sched_param)
Change the base scheduling parameters of a thread.
Definition: thread.c:1834
int xntimer_start(struct xntimer *timer, xnticks_t value, xnticks_t interval, xntmode_t mode)
Arm a timer.
Definition: timer.c:113
static void xntimer_stop(struct xntimer *timer)
Disarm a timer.
Definition: timer.h:471
nanosecs_abs_t rtdm_clock_read(void)
Get system time.
nanosecs_abs_t rtdm_clock_read_monotonic(void)
Get monotonic time.
int rtdm_dev_register(struct rtdm_device *device)
Register a RTDM device.
Definition: device.c:389
#define RTDM_MAX_MINOR
Maximum number of named devices per driver.
Definition: driver.h:97
void rtdm_dev_unregister(struct rtdm_device *device)
Unregister a RTDM device.
Definition: device.c:536
int rtdm_drv_set_sysclass(struct rtdm_driver *drv, struct class *cls)
Set the kernel device class of a RTDM driver.
Definition: device.c:609
int rtdm_irq_enable(rtdm_irq_t *irq_handle)
Enable interrupt line.
int rtdm_irq_request(rtdm_irq_t *irq_handle, unsigned int irq_no, rtdm_irq_handler_t handler, unsigned long flags, const char *device_name, void *arg)
Register an interrupt handler.
Definition: drvlib.c:1441
int rtdm_irq_disable(rtdm_irq_t *irq_handle)
Disable interrupt line.
int(* rtdm_irq_handler_t)(rtdm_irq_t *irq_handle)
Interrupt handler.
Definition: driver.h:823
int rtdm_irq_free(rtdm_irq_t *irq_handle)
Release an interrupt handler.
int rtdm_nrtsig_init(rtdm_nrtsig_t *nrt_sig, rtdm_nrtsig_handler_t handler, void *arg)
Register a non-real-time signal handler.
void rtdm_nrtsig_destroy(rtdm_nrtsig_t *nrt_sig)
Release a non-realtime signal handler.
void rtdm_nrtsig_pend(rtdm_nrtsig_t *nrt_sig)
Trigger non-real-time signal.
Definition: drvlib.c:1592
void rtdm_schedule_nrt_work(struct work_struct *lostage_work)
Put a work task in Linux non real-time global workqueue from primary mode.
Definition: drvlib.c:1623
void(* rtdm_nrtsig_handler_t)(rtdm_nrtsig_t *nrt_sig, void *arg)
Non-real-time signal handler.
Definition: driver.h:896
void rtdm_event_signal(rtdm_event_t *event)
Signal an event occurrence.
Definition: drvlib.c:797
int rtdm_event_select(rtdm_event_t *event, rtdm_selector_t *selector, enum rtdm_selecttype type, unsigned int fd_index)
Bind a selector to an event.
Definition: drvlib.c:978
int rtdm_event_wait(rtdm_event_t *event)
Wait on event occurrence.
Definition: drvlib.c:839
void rtdm_event_clear(rtdm_event_t *event)
Clear event state.
Definition: drvlib.c:940
void rtdm_event_destroy(rtdm_event_t *event)
Destroy an event.
Definition: drvlib.c:758
void rtdm_event_pulse(rtdm_event_t *event)
Signal an event occurrence to currently listening waiters.
Definition: drvlib.c:779
void rtdm_event_init(rtdm_event_t *event, unsigned long pending)
Initialise an event.
Definition: drvlib.c:732
int rtdm_event_timedwait(rtdm_event_t *event, nanosecs_rel_t timeout, rtdm_toseq_t *timeout_seq)
Wait on event occurrence with timeout.
Definition: drvlib.c:877
int rtdm_mutex_timedlock(rtdm_mutex_t *mutex, nanosecs_rel_t timeout, rtdm_toseq_t *timeout_seq)
Request a mutex with timeout.
Definition: drvlib.c:1358
int rtdm_mutex_lock(rtdm_mutex_t *mutex)
Request a mutex.
Definition: drvlib.c:1324
void rtdm_mutex_init(rtdm_mutex_t *mutex)
Initialise a mutex.
Definition: drvlib.c:1257
void rtdm_mutex_unlock(rtdm_mutex_t *mutex)
Release a mutex.
Definition: drvlib.c:1294
void rtdm_mutex_destroy(rtdm_mutex_t *mutex)
Destroy a mutex.
Definition: drvlib.c:1275
int rtdm_sem_down(rtdm_sem_t *sem)
Decrement a semaphore.
Definition: drvlib.c:1074
void rtdm_sem_up(rtdm_sem_t *sem)
Increment a semaphore.
Definition: drvlib.c:1171
int rtdm_sem_timeddown(rtdm_sem_t *sem, nanosecs_rel_t timeout, rtdm_toseq_t *timeout_seq)
Decrement a semaphore with timeout.
Definition: drvlib.c:1112
int rtdm_sem_select(rtdm_sem_t *sem, rtdm_selector_t *selector, enum rtdm_selecttype type, unsigned int fd_index)
Bind a selector to a semaphore.
Definition: drvlib.c:1213
void rtdm_sem_init(rtdm_sem_t *sem, unsigned long value)
Initialise a semaphore.
Definition: drvlib.c:1019
void rtdm_sem_destroy(rtdm_sem_t *sem)
Destroy a semaphore.
Definition: drvlib.c:1044
unsigned long rtdm_lockctx_t
Variable to save the context while holding a lock.
Definition: driver.h:553
static void rtdm_lock_get(rtdm_lock_t *lock)
Acquire lock from non-preemptible contexts.
Definition: driver.h:574
static void rtdm_lock_init(rtdm_lock_t *lock)
Dynamic lock initialisation.
Definition: driver.h:562
static void rtdm_lock_put(rtdm_lock_t *lock)
Release lock without preemption restoration.
Definition: driver.h:588
static void rtdm_lock_put_irqrestore(rtdm_lock_t *lock, rtdm_lockctx_t context)
Release lock and restore preemption state.
Definition: driver.h:625
ipipe_spinlock_t rtdm_lock_t
Lock variable.
Definition: driver.h:550
void rtdm_toseq_init(rtdm_toseq_t *timeout_seq, nanosecs_rel_t timeout)
Initialise a timeout sequence.
Definition: drvlib.c:707
void rtdm_waitqueue_destroy(struct rtdm_waitqueue *wq)
Deletes a RTDM wait queue.
void rtdm_waitqueue_init(struct rtdm_waitqueue *wq)
Initialize a RTDM wait queue.
rtdm_selecttype
Definition: driver.h:111
@ RTDM_SELECTTYPE_EXCEPT
Select exceptional events.
Definition: driver.h:119
@ RTDM_SELECTTYPE_WRITE
Select ouput buffer availability events.
Definition: driver.h:116
@ RTDM_SELECTTYPE_READ
Select input data availability events.
Definition: driver.h:113
int rtdm_task_should_stop(void)
Check for pending termination request.
int rtdm_task_sleep_abs(nanosecs_abs_t wakeup_time, enum rtdm_timer_mode mode)
Sleep until a specified absolute time.
void rtdm_task_set_priority(rtdm_task_t *task, int priority)
Adjust real-time task priority.
void rtdm_task_join(rtdm_task_t *task)
Wait on a real-time task to terminate.
Definition: drvlib.c:463
void(* rtdm_task_proc_t)(void *arg)
Real-time task procedure.
Definition: driver.h:996
int rtdm_task_init(rtdm_task_t *task, const char *name, rtdm_task_proc_t task_proc, void *arg, int priority, nanosecs_rel_t period)
Initialise and start a real-time task.
Definition: drvlib.c:108
int rtdm_task_set_period(rtdm_task_t *task, nanosecs_abs_t start_date, nanosecs_rel_t period)
Adjust real-time task period.
int rtdm_task_sleep_until(nanosecs_abs_t wakeup_time)
Sleep until a specified absolute time.
void rtdm_task_destroy(rtdm_task_t *task)
Destroy a real-time task.
void rtdm_wait_prepare(struct rtdm_wait_context *wc)
Register wait context.
void rtdm_wait_complete(struct rtdm_wait_context *wc)
Mark completion for a wait context.
int rtdm_task_wait_period(unsigned long *overruns_r)
Wait on next real-time task period.
void rtdm_task_busy_sleep(nanosecs_rel_t delay)
Busy-wait a specified amount of time.
Definition: drvlib.c:486
int rtdm_task_sleep(nanosecs_rel_t delay)
Sleep a specified amount of time.
int rtdm_wait_is_completed(struct rtdm_wait_context *wc)
Test completion of a wait context.
int rtdm_task_unblock(rtdm_task_t *task)
Activate a blocked real-time task.
rtdm_task_t * rtdm_task_current(void)
Get current real-time task.
void(* rtdm_timer_handler_t)(rtdm_timer_t *timer)
Timer handler.
Definition: driver.h:937
int rtdm_timer_start(rtdm_timer_t *timer, nanosecs_abs_t expiry, nanosecs_rel_t interval, enum rtdm_timer_mode mode)
Start a timer.
Definition: drvlib.c:567
void rtdm_timer_stop(rtdm_timer_t *timer)
Stop a timer.
Definition: drvlib.c:589
int rtdm_timer_init(rtdm_timer_t *timer, rtdm_timer_handler_t handler, const char *name)
Initialise a timer.
Definition: drvlib.c:517
void rtdm_timer_destroy(rtdm_timer_t *timer)
Destroy a timer.
Definition: drvlib.c:537
rtdm_timer_mode
Definition: driver.h:944
int rtdm_timer_start_in_handler(rtdm_timer_t *timer, nanosecs_abs_t expiry, nanosecs_rel_t interval, enum rtdm_timer_mode mode)
Start a timer from inside a timer handler.
void rtdm_timer_stop_in_handler(rtdm_timer_t *timer)
Stop a timer from inside a timer handler.
@ RTDM_TIMERMODE_ABSOLUTE
Monotonic timer with absolute timeout.
Definition: driver.h:949
@ RTDM_TIMERMODE_REALTIME
Adjustable timer with absolute timeout.
Definition: driver.h:952
@ RTDM_TIMERMODE_RELATIVE
Monotonic timer with relative timeout.
Definition: driver.h:946
int rtdm_munmap(void *ptr, size_t len)
Unmap a user memory range.
Definition: drvlib.c:2121
int rtdm_read_user_ok(struct rtdm_fd *fd, const void __user *ptr, size_t size)
Check if read access to user-space memory block is safe.
int rtdm_rw_user_ok(struct rtdm_fd *fd, const void __user *ptr, size_t size)
Check if read/write access to user-space memory block is safe.
int rtdm_copy_from_user(struct rtdm_fd *fd, void *dst, const void __user *src, size_t size)
Copy user-space memory block to specified buffer.
void * rtdm_malloc(size_t size)
Allocate memory block.
int rtdm_iomap_to_user(struct rtdm_fd *fd, phys_addr_t src_addr, size_t len, int prot, void **pptr, struct vm_operations_struct *vm_ops, void *vm_private_data)
Map an I/O memory range into the address space of the user.
Definition: drvlib.c:2003
int rtdm_mmap_kmem(struct vm_area_struct *vma, void *va)
Map a kernel logical memory range to a virtual user area.
Definition: drvlib.c:2047
int rtdm_safe_copy_to_user(struct rtdm_fd *fd, void __user *dst, const void *src, size_t size)
Check if read/write access to user-space memory block is safe and copy specified buffer to it.
int rtdm_copy_to_user(struct rtdm_fd *fd, void __user *dst, const void *src, size_t size)
Copy specified buffer to user-space memory block.
int rtdm_mmap_to_user(struct rtdm_fd *fd, void *src_addr, size_t len, int prot, void **pptr, struct vm_operations_struct *vm_ops, void *vm_private_data)
Map a kernel memory range into the address space of the user.
Definition: drvlib.c:1934
void rtdm_free(void *ptr)
Release real-time memory block.
int rtdm_in_rt_context(void)
Test if running in a real-time task.
int rtdm_rt_capable(struct rtdm_fd *fd)
Test if the caller is capable of running in real-time context.
int rtdm_mmap_iomem(struct vm_area_struct *vma, phys_addr_t pa)
Map an I/O memory range to a virtual user area.
Definition: drvlib.c:2100
bool rtdm_available(void)
Test if the real-time core is available.
int rtdm_mmap_vmem(struct vm_area_struct *vma, void *va)
Map a virtual memory range to a virtual user area.
Definition: drvlib.c:2072
int rtdm_strncpy_from_user(struct rtdm_fd *fd, char *dst, const char __user *src, size_t count)
Copy user-space string to specified buffer.
int rtdm_safe_copy_from_user(struct rtdm_fd *fd, void *dst, const void __user *src, size_t size)
Check if read access to user-space memory block and copy it to specified buffer.
uint64_t nanosecs_abs_t
RTDM type for representing absolute dates.
Definition: rtdm.h:43
int64_t nanosecs_rel_t
RTDM type for representing relative intervals.
Definition: rtdm.h:49
Copyright © 2011 Gilles Chanteperdrix gilles.chanteperdrix@xenomai.org.
Definition: atomic.h:24
Device context.
Definition: driver.h:136
char dev_private[0]
Begin of driver defined context data structure.
Definition: driver.h:144
struct rtdm_device * device
Set of active device operation handlers.
Definition: driver.h:141
RTDM device.
Definition: driver.h:338
int minor
Minor number of the device.
Definition: driver.h:369
void * device_data
Driver definable device data.
Definition: driver.h:342
struct rtdm_driver * driver
Device driver.
Definition: driver.h:340
const char * label
Device label template for composing the device name.
Definition: driver.h:354
RTDM driver.
Definition: driver.h:249
struct rtdm_fd_ops ops
I/O operation handlers.
Definition: driver.h:275
int socket_type
Protocol device identification: socket type (SOCK_xxx)
Definition: driver.h:273
int device_flags
Device flags, see Device Flags for details .
Definition: driver.h:260
int base_minor
Base minor for named devices.
Definition: driver.h:284
size_t context_size
Size of the private memory area the core should automatically allocate for each open file descriptor,...
Definition: driver.h:269
int device_count
Count of devices this driver manages.
Definition: driver.h:282
struct rtdm_sm_ops smops
State management handlers.
Definition: driver.h:277
int protocol_family
Protocol device identification: protocol family (PF_xxx)
Definition: driver.h:271
struct rtdm_profile_info profile_info
Class profile information.
Definition: driver.h:255
RTDM profile information.
Definition: driver.h:215
int version
Supported device profile version.
Definition: driver.h:224
unsigned int magic
Reserved.
Definition: driver.h:226
int subclass_id
Device sub-class, see RTDM_SUBCLASS_xxx definition in the Device Profiles.
Definition: driver.h:222
const char * name
Device class name.
Definition: driver.h:217
int class_id
Device class ID, see RTDM_CLASS_xxx.
Definition: driver.h:219
RTDM state management handlers.
Definition: driver.h:236
int(* stop)(struct rtdm_driver *drv)
Handler called upon transition to COBALT_STATE_TEARDOWN.
Definition: driver.h:240
int(* start)(struct rtdm_driver *drv)
Handler called upon transition to COBALT_STATE_WARMUP.
Definition: driver.h:238