diff -uNrp comedi-0.7.70/comedi/drivers/comedi_rt_timer.c comedi_fusion/comedi/drivers/comedi_rt_timer.c --- comedi-0.7.70/comedi/drivers/comedi_rt_timer.c 2005-03-05 07:18:19.000000000 +0100 +++ comedi_fusion/comedi/drivers/comedi_rt_timer.c 2005-05-26 20:54:32.000000000 +0200 @@ -106,12 +106,22 @@ static inline RTIME nano2count(long long #define start_rt_timer(x) #define stop_rt_timer() -#endif +#endif /* CONFIG_COMEDI_RTL */ + #ifdef CONFIG_COMEDI_RTAI #include #include -#endif +#endif /* CONFIG_COMEDI_RTAI */ + +#ifdef CONFIG_COMEDI_FUSION +#include +#include +// fusion-rtai compatibility +#define stop_rt_timer() rt_timer_stop() +#define rt_get_time() rt_timer_tsc() + +#endif /* CONFIG_COMEDI_FUSION */ /* This defines the fastest speed we will emulate. Note that * without a watchdog (like in RTAI), we could easily overrun our @@ -138,6 +148,11 @@ typedef struct{ int subd; // subdevice we are emulating commands for RT_TASK *rt_task; // rt task that starts scans RT_TASK *scan_task; // rt task that controls conversion timing in a scan +#ifdef CONFIG_COMEDI_FUSION + RT_SEM *sem_timer; + RT_SEM *sem_scan; + RTIME start_timer; +#endif /* CONFIG_COMEDI_FUSION */ /* io_function can point to either an input or output function * depending on what kind of subdevice we are emulating for */ int (*io_function)(comedi_device *dev, comedi_cmd *cmd, unsigned int index); @@ -163,7 +178,29 @@ static int timer_cancel(comedi_device *d return 0; } + // checks for scan timing error +#ifdef CONFIG_COMEDI_FUSION +inline static int check_scan_timing(comedi_device *dev, + unsigned long long scan) +{ + RTIME now, expected ,timing_error; + + expected = devpriv->start + scan * rt_timer_ns2ticks(devpriv->scan_period); + now = rt_timer_tsc(); + /* With Vesuvio RTIME is long long and + with Fusion RTIME is unsigned long long */ + timing_error = (now > expected) ? now - expected : expected - now; + + if(timing_error > devpriv->scan_period){ + comedi_error(dev, "timing error"); + printk("scan started %llu ns late\n", rt_timer_ticks2ns(timing_error)); + return -1; + } + return 0; +} + +#else /* ! CONFIG_COMEDI_FUSION */ inline static int check_scan_timing(comedi_device *dev, unsigned long long scan) { @@ -179,8 +216,30 @@ inline static int check_scan_timing(come return 0; } +#endif /* CONFIG_COMEDI_FUSION */ // checks for conversion timing error +#ifdef CONFIG_COMEDI_FUSION +inline static int check_conversion_timing(comedi_device *dev, + RTIME scan_start, unsigned int conversion) +{ + RTIME now, expected, timing_error; + + expected = scan_start + conversion * rt_timer_ns2ticks(devpriv->convert_period); + now = rt_timer_tsc(); + /* With Vesuvio RTIME is long long and + with Fusion RTIME is unsigned long long */ + timing_error = (now > expected) ? now - expected : expected - now; + if(timing_error > devpriv->convert_period){ + comedi_error(dev, "timing error"); + printk("conversion started %llu ns late\n", rt_timer_ticks2ns(timing_error)); + return -1; + } + + return 0; +} +#else /* ! CONFIG_COMEDI_FUSION */ + inline static int check_conversion_timing(comedi_device *dev, RTIME scan_start, unsigned int conversion) { @@ -196,6 +255,8 @@ inline static int check_conversion_timin return 0; } +#endif /* CONFIG_COMEDI_FUSION */ + // devpriv->io_function for an input subdevice static int timer_data_read(comedi_device *dev, comedi_cmd *cmd, @@ -281,7 +342,11 @@ static int timer_dio_read(comedi_device } // performs scans +#ifdef CONFIG_COMEDI_FUSION +static void scan_task_func(void *d) +#else static void scan_task_func(int d) +#endif /* CONFIG_COMEDI_FUSION */ { comedi_device *dev=(comedi_device *)d; comedi_subdevice *s = dev->subdevices + 0; @@ -293,17 +358,40 @@ static void scan_task_func(int d) // every comedi_cmd causes one execution of while loop while(1){ +#ifdef CONFIG_COMEDI_FUSION + rt_sem_p(devpriv->sem_scan,TM_INFINITE); + ret = rt_task_set_periodic(NULL,TM_NOW, + devpriv->convert_period); + if(ret < 0){ + comedi_error(dev, "error setting periodic mode"); + async->events |= COMEDI_CB_ERROR; + goto cleanup; + } + async = s->async; + cmd=&s->async->cmd; +#endif /* CONFIG_COMEDI_FUSION */ devpriv->scan_task_active = 1; // each for loop completes one scan for(n = 0; n < cmd->stop_arg || cmd->stop_src == TRIG_NONE; n++){ if(n){ - // suspend task until next scan - ret = rt_task_suspend(devpriv->scan_task); - if(ret < 0){ - comedi_error(dev, "error suspending scan task"); - async->events |= COMEDI_CB_ERROR; - goto cleanup; - } +#ifdef CONFIG_COMEDI_FUSION + rt_sem_p(devpriv->sem_scan,TM_INFINITE); + ret = rt_task_set_periodic(NULL,TM_NOW, + devpriv->convert_period); + if(ret < 0){ + comedi_error(dev, "error setting periodic mode"); + async->events |= COMEDI_CB_ERROR; + goto cleanup; + } +#else /* CONFIG_COMEDI_FUSION */ + // suspend task until next scan + ret = rt_task_suspend(devpriv->scan_task); + if(ret < 0){ + comedi_error(dev, "error suspending scan task"); + async->events |= COMEDI_CB_ERROR; + goto cleanup; + } +#endif /* CONFIG_COMEDI_FUSION */ } // check if stop flag was set (by timer_cancel()) if(devpriv->stop) @@ -342,25 +430,40 @@ cleanup: comedi_event(dev, s, async->events); async->events = 0; devpriv->scan_task_active = 0; + + +#ifndef CONFIG_COMEDI_FUSION // suspend task until next comedi_cmd rt_task_suspend(devpriv->scan_task); +#endif /* CONFIG_COMEDI_FUSION */ } } +#ifdef CONFIG_COMEDI_FUSION +static void timer_task_func(void *d) +#else static void timer_task_func(int d) +#endif /* CONFIG_COMEDI_FUSION */ { comedi_device *dev=(comedi_device *)d; comedi_subdevice *s = dev->subdevices + 0; - comedi_cmd *cmd=&s->async->cmd; - int ret; + comedi_cmd *cmd; + int ret = 0; unsigned long long n; + // every comedi_cmd causes one execution of while loop while(1){ +#ifdef CONFIG_COMEDI_FUSION + /* Wait for a new comedi_cmd */ + rt_sem_p(devpriv->sem_timer,TM_INFINITE); + rt_task_set_periodic(NULL,devpriv->start_timer, + devpriv->scan_period); + cmd=&s->async->cmd; +#endif /* CONFIG_COMEDI_FUSION */ devpriv->rt_task_active = 1; devpriv->scan_task_active = 1; devpriv->start = rt_get_time(); - for(n = 0; n < cmd->stop_arg || cmd->stop_src == TRIG_NONE; n++){ // scan timing if(n) @@ -368,9 +471,13 @@ static void timer_task_func(int d) if(devpriv->scan_task_active == 0){ goto cleanup; } - ret = rt_task_make_periodic(devpriv->scan_task, - devpriv->start + devpriv->scan_period * n, - devpriv->convert_period); +#ifdef CONFIG_COMEDI_FUSION + rt_sem_v(devpriv->sem_scan); +#else /* ! CONFIG_COMEDI_FUSION */ + ret = rt_task_make_periodic(devpriv->scan_task, + devpriv->start + devpriv->scan_period * n, + devpriv->convert_period); +#endif /* CONFIG_COMEDI_FUSION */ if(ret < 0){ comedi_error(dev, "bug!"); } @@ -378,12 +485,17 @@ static void timer_task_func(int d) cleanup: - devpriv->rt_task_active = 0; - // suspend until next comedi_cmd - rt_task_suspend(devpriv->rt_task); + devpriv->rt_task_active = 0; + +#ifndef CONFIG_COMEDI_FUSION + // suspend until next comedi_cmd + rt_task_suspend(devpriv->rt_task); +#endif /* CONFIG_COMEDI_FUSION */ + } } + static int timer_insn(comedi_device *dev,comedi_subdevice *s, comedi_insn *insn,lsampl_t *data) { @@ -517,10 +629,18 @@ static int timer_cmd(comedi_device *dev, } switch(cmd->scan_begin_src){ case TRIG_TIMER: - devpriv->scan_period = nano2count(cmd->scan_begin_arg); +#ifdef CONFIG_COMEDI_FUSION + devpriv->scan_period = cmd->scan_begin_arg; +#else /* ! CONFIG_COMEDI_FUSION */ + devpriv->scan_period = nano2count(cmd->scan_begin_arg); +#endif /* CONFIG_COMEDI_FUSION */ break; case TRIG_FOLLOW: +#ifdef CONFIG_COMEDI_FUSION + devpriv->scan_period = cmd->convert_arg * cmd->scan_end_arg; +#else /* ! CONFIG_COMEDI_FUSION */ devpriv->scan_period = nano2count(cmd->convert_arg * cmd->scan_end_arg); +#endif /* CONFIG_COMEDI_FUSION */ break; default: comedi_error(dev, "bug setting scan period!"); @@ -529,7 +649,11 @@ static int timer_cmd(comedi_device *dev, } switch(cmd->convert_src){ case TRIG_TIMER: - devpriv->convert_period = nano2count(cmd->convert_arg); +#ifdef CONFIG_COMEDI_FUSION + devpriv->convert_period = cmd->convert_arg; +#else /* ! CONFIG_COMEDI_FUSION */ + devpriv->convert_period = nano2count(cmd->convert_arg); +#endif /* CONFIG_COMEDI_FUSION */ break; case TRIG_NOW: devpriv->convert_period = 1; @@ -562,23 +686,42 @@ static int timer_start_cmd(comedi_device { comedi_async *async = s->async; comedi_cmd *cmd = &async->cmd; - RTIME now, delay, period; + RTIME now, delay; +#ifndef CONFIG_COMEDI_FUSION + RTIME period; int ret; - +#endif /* CONFIG_COMEDI_FUSION */ + devpriv->stop = 0; s->async->events = 0; - - +#ifdef CONFIG_COMEDI_FUSION + if(cmd->start_src == TRIG_NOW) + delay = rt_timer_ns2ticks(cmd->start_arg); + else + delay = 0; + + if(delay ==0) + now = TM_NOW; + else + now=rt_timer_tsc(); +#else /* ! CONFIG_COMEDI_FUSION */ if(cmd->start_src == TRIG_NOW) delay = nano2count(cmd->start_arg); else delay = 0; now=rt_get_time(); +#endif /* CONFIG_COMEDI_FUSION */ + /* Using 'period' this way gets around some weird bug in gcc-2.95.2 * that generates the compile error 'internal error--unrecognizable insn' * when rt_task_make_period() is called (observed with rtlinux-3.1, linux-2.2.19). * - fmhess */ + +#ifdef CONFIG_COMEDI_FUSION + devpriv->start_timer = now + delay; + rt_sem_v(devpriv->sem_timer); +#else /* ! CONFIG_COMEDI_FUSION */ period = devpriv->scan_period; ret = rt_task_make_periodic(devpriv->rt_task, now + delay, period); @@ -587,6 +730,8 @@ static int timer_start_cmd(comedi_device comedi_error(dev, "error starting rt_task"); return ret; } +#endif /* CONFIG_COMEDI_FUSION */ + return 0; } @@ -596,8 +741,15 @@ static int timer_attach(comedi_device *d comedi_subdevice *s, *emul_s; comedi_device *emul_dev; /* These should probably be devconfig options[] */ +#ifdef CONFIG_COMEDI_FUSION + /* With Fusion, 1 is the lowest priority and + 99 is the highest priority */ + const int timer_priority = 4; + const int scan_priority = timer_priority - 1; +#else /* ! CONFIG_COMEDI_FUSION */ const int timer_priority = 4; const int scan_priority = timer_priority + 1; +#endif /* CONFIG_COMEDI_FUSION */ char path[20]; printk("comedi%d: timer: ",dev->minor); @@ -654,6 +806,56 @@ static int timer_attach(comedi_device *d return -EINVAL; } +#ifdef CONFIG_COMEDI_FUSION + + devpriv->sem_timer = kmalloc(sizeof(RT_SEM),GFP_KERNEL); + rt_sem_create(devpriv->sem_timer,"SEM TIMER",0,0); + devpriv->sem_scan = kmalloc(sizeof(RT_SEM),GFP_KERNEL); + rt_sem_create(devpriv->sem_scan,"SEM SCAN",0,0); + + rt_timer_start(TM_ONESHOT); + devpriv->timer_running = 1; + + devpriv->rt_task = kmalloc(sizeof(RT_TASK),GFP_KERNEL); + memset(devpriv->rt_task,0,sizeof(RT_TASK)); + + // initialize real-time tasks + ret = rt_task_create(devpriv->rt_task, + "TIMER TASK", + 3000, + timer_priority, + /*T_SUSP*/0); + if(ret==0) + ret = rt_task_start(devpriv->rt_task, + timer_task_func, + (void*)dev); + if(ret < 0) { + comedi_error(dev, "error initalizing rt_task"); + kfree(devpriv->rt_task); + devpriv->rt_task = 0; + return ret; + } + + devpriv->scan_task = kmalloc(sizeof(RT_TASK),GFP_KERNEL); + memset(devpriv->scan_task,0,sizeof(RT_TASK)); + + ret = rt_task_create(devpriv->scan_task, + "SCAN TASK", + 3000, + scan_priority, + /*T_SUSP*/0); + if(ret==0) + ret = rt_task_start(devpriv->scan_task, + scan_task_func, + (void*)dev); + if(ret < 0){ + comedi_error(dev, "error initalizing scan_task"); + kfree(devpriv->scan_task); + devpriv->scan_task = 0; + return ret; + } + +#else /* ! CONFIG_COMEDI_FUSION */ rt_set_oneshot_mode(); start_rt_timer( 1 ); devpriv->timer_running = 1; @@ -682,7 +884,7 @@ static int timer_attach(comedi_device *d devpriv->scan_task = 0; return ret; } - +#endif /* CONFIG_COMEDI_FUSION */ return 1; } @@ -702,8 +904,14 @@ static int timer_detach(comedi_device *d } if(devpriv->timer_running) stop_rt_timer(); +#ifdef CONFIG_COMEDI_FUSION + if(devpriv->sem_timer) + rt_sem_delete(devpriv->sem_timer); + if(devpriv->sem_scan) + rt_sem_delete(devpriv->sem_scan); +#endif /* CONFIG_COMEDI_FUSION */ if(devpriv->device) - comedi_close(devpriv->device); + comedi_close(devpriv->device); } return 0; } diff -uNrp comedi-0.7.70/comedi/rt.c comedi_fusion/comedi/rt.c --- comedi-0.7.70/comedi/rt.c 2005-02-04 03:14:59.000000000 +0100 +++ comedi_fusion/comedi/rt.c 2005-05-26 00:22:18.000000000 +0200 @@ -48,6 +48,10 @@ #define RT_spin_unlock_irq(x) rt_spin_unlock_irq(x) #endif +#ifdef CONFIG_COMEDI_FUSION +#include +#endif + #ifdef CONFIG_COMEDI_RTL #include #include @@ -139,7 +143,7 @@ int comedi_request_irq(unsigned irq, irq if(!it) return -ENOMEM; memset(it,0,sizeof(struct comedi_irq_struct)); - + it->handler=handler; it->irq=irq; it->dev_id=dev_id; @@ -384,6 +388,132 @@ void comedi_rt_cleanup(void) #endif +/* Fusion section */ +#ifdef CONFIG_COMEDI_FUSION + +#ifndef HAVE_RT_REQUEST_IRQ_WITH_ARG +#define DECLARE_VOID_IRQ(irq) \ +static void handle_void_irq_ ## irq (void){ handle_void_irq(irq);} + +static void handle_void_irq(int irq) +{ + int i; + struct comedi_irq_struct *it; + + for( i = 0; i < MAX_IRQ_SHARING; i++ ) + { + it = comedi_irqs[ irq ][ i ]; + if( it == NULL ) continue; + it->handler( irq, it->dev_id, NULL ); + } + rthal_irq_enable(irq); //needed by rtai-adeos, seems like it shouldn't hurt earlier versions +} + +DECLARE_VOID_IRQ(0); +DECLARE_VOID_IRQ(1); +DECLARE_VOID_IRQ(2); +DECLARE_VOID_IRQ(3); +DECLARE_VOID_IRQ(4); +DECLARE_VOID_IRQ(5); +DECLARE_VOID_IRQ(6); +DECLARE_VOID_IRQ(7); +DECLARE_VOID_IRQ(8); +DECLARE_VOID_IRQ(9); +DECLARE_VOID_IRQ(10); +DECLARE_VOID_IRQ(11); +DECLARE_VOID_IRQ(12); +DECLARE_VOID_IRQ(13); +DECLARE_VOID_IRQ(14); +DECLARE_VOID_IRQ(15); +DECLARE_VOID_IRQ(16); +DECLARE_VOID_IRQ(17); +DECLARE_VOID_IRQ(18); +DECLARE_VOID_IRQ(19); +DECLARE_VOID_IRQ(20); +DECLARE_VOID_IRQ(21); +DECLARE_VOID_IRQ(22); +DECLARE_VOID_IRQ(23); + +typedef void (*V_FP_V)(void); +static V_FP_V handle_void_irq_ptrs[]={ + handle_void_irq_0, + handle_void_irq_1, + handle_void_irq_2, + handle_void_irq_3, + handle_void_irq_4, + handle_void_irq_5, + handle_void_irq_6, + handle_void_irq_7, + handle_void_irq_8, + handle_void_irq_9, + handle_void_irq_10, + handle_void_irq_11, + handle_void_irq_12, + handle_void_irq_13, + handle_void_irq_14, + handle_void_irq_15, + handle_void_irq_16, + handle_void_irq_17, + handle_void_irq_18, + handle_void_irq_19, + handle_void_irq_20, + handle_void_irq_21, + handle_void_irq_22, + handle_void_irq_23, +}; +/* if you need more, fix it yourself... */ + +static int comedi_rt_get_irq(struct comedi_irq_struct *it) +{ + rthal_irq_enable(it->irq); + rthal_irq_request(it->irq, + (rthal_irq_handler_t)handle_void_irq_ptrs[it->irq], + NULL); + return 0; +} + +static int comedi_rt_release_irq(struct comedi_irq_struct *it) +{ + rthal_irq_release(it->irq); + rthal_irq_disable(it->irq); + return 0; +} +#else + +static int comedi_rt_get_irq(struct comedi_irq_struct *it) +{ + int ret; + + ret = rt_request_global_irq_arg(it->irq,it->handler,it->flags, + it->device,it->dev_id); + if(ret<0){ + rt_printk("rt_request_global_irq_arg() returned %d\n",ret); + return ret; + } + rt_startup_irq(it->irq); + + return 0; +} + +static int comedi_rt_release_irq(struct comedi_irq_struct *it) +{ + rt_shutdown_irq(it->irq); + rt_free_global_irq(it->irq); + return 0; +} +#endif + +void comedi_rt_init(void) +{ + rt_pend_tq_init(); +} + +void comedi_rt_cleanup(void) +{ + rt_pend_tq_cleanup(); +} + +#endif /* CONFIG_COMEDI_FUSION */ /* RTLinux section */ #ifdef CONFIG_COMEDI_RTL diff -uNrp comedi-0.7.70/comedi/rt_pend_tq.c comedi_fusion/comedi/rt_pend_tq.c --- comedi-0.7.70/comedi/rt_pend_tq.c 2002-12-02 21:03:27.000000000 +0100 +++ comedi_fusion/comedi/rt_pend_tq.c 2005-05-26 19:04:54.000000000 +0200 @@ -8,6 +8,9 @@ #ifdef CONFIG_COMEDI_RTAI #include #endif +#ifdef CONFIG_COMEDI_FUSION +#include +#endif #ifdef CONFIG_COMEDI_RTL #include #endif @@ -51,6 +54,9 @@ int rt_pend_call(void (*func)(int arg1, #ifdef CONFIG_COMEDI_RTAI rt_pend_linux_srq(rt_pend_tq_irq); #endif +#ifdef CONFIG_COMEDI_FUSION + rthal_apc_schedule(rt_pend_tq_irq); +#endif #ifdef CONFIG_COMEDI_RTL rtl_global_pend_irq(rt_pend_tq_irq); @@ -58,10 +64,11 @@ int rt_pend_call(void (*func)(int arg1, return 0; } -#ifdef CONFIG_COMEDI_RTAI +#ifdef CONFIG_COMEDI_RTAI void rt_pend_irq_handler(void) -#endif -#ifdef CONFIG_COMEDI_RTL +#elif defined(CONFIG_COMEDI_FUSION) +void rt_pend_irq_handler(void * cookie) +#elif defined(CONFIG_COMEDI_RTL) void rt_pend_irq_handler(int irq, void *dev, struct pt_regs * regs) #endif { @@ -77,6 +84,9 @@ int rt_pend_tq_init(void) #ifdef CONFIG_COMEDI_RTAI rt_pend_tq_irq=rt_request_srq(0,rt_pend_irq_handler,NULL); #endif +#ifdef CONFIG_COMEDI_FUSION + rt_pend_tq_irq=rthal_apc_alloc("comedi APC" ,rt_pend_irq_handler, NULL); +#endif #ifdef CONFIG_COMEDI_RTL rt_pend_tq_irq=rtl_get_soft_irq(rt_pend_irq_handler,"rt_pend_irq"); #endif @@ -93,6 +103,9 @@ void rt_pend_tq_cleanup(void) #ifdef CONFIG_COMEDI_RTAI rt_free_srq(rt_pend_tq_irq); #endif +#ifdef CONFIG_COMEDI_FUSION + rthal_apc_free(rt_pend_tq_irq); +#endif #ifdef CONFIG_COMEDI_RTL free_irq(rt_pend_tq_irq,NULL); #endif diff -uNrp comedi-0.7.70/include/linux/comedidev.h comedi_fusion/include/linux/comedidev.h --- comedi-0.7.70/include/linux/comedidev.h 2005-03-19 19:51:51.000000000 +0100 +++ comedi_fusion/include/linux/comedidev.h 2005-05-25 22:39:42.000000000 +0200 @@ -46,6 +46,9 @@ #include +#ifdef CONFIG_COMEDI_FUSION +#define rt_printk(format, args...) printk(format , ## args ) +#endif /* CONFIG_COMEDI_FUSION */ #define DPRINTK(format, args...) do{ \ if(comedi_debug)printk("comedi: " format , ## args ); \ diff -uNrp comedi-0.7.70/m4/rtai.m4 comedi_fusion/m4/rtai.m4 --- comedi-0.7.70/m4/rtai.m4 2004-05-17 21:38:08.000000000 +0200 +++ comedi_fusion/m4/rtai.m4 2005-05-25 22:39:42.000000000 +0200 @@ -23,7 +23,15 @@ AC_DEFUN([DS_RTAI], fi $1 AC_MSG_RESULT([found]) - AC_DEFINE([CONFIG_COMEDI_RTAI],[true],[Define if kernel is RTAI patched]) + + FUSION_TEST=`${RTAI_DIR}/bin/rtai-config --version | cut -d"-" -f2 ` + if test "${FUSION_TEST}" = "fusion" + then + AC_DEFINE([CONFIG_COMEDI_FUSION],[true],[Define if kernel is RTAI patched]) + else + AC_DEFINE([CONFIG_COMEDI_RTAI],[true],[Define if kernel is RTAI patched]) + fi + else $2 fi