Module: xenomai-2.5
Branch: master
Commit: 036120a6c8846d2706be66b498a7cfc9e879bca4
URL:    
http://git.xenomai.org/?p=xenomai-2.5.git;a=commit;h=036120a6c8846d2706be66b498a7cfc9e879bca4

Author: Philippe Gerum <r...@xenomai.org>
Date:   Thu Oct 14 09:29:07 2010 +0200

hal/arm: do not assume single global timer chip

This patch revamps the timer-related code to match the requirements of
SMP configurations with per-cpu local timers.

---

 ksrc/arch/arm/hal.c |  468 ++++++++++++++++++++++++++++++++-------------------
 1 files changed, 294 insertions(+), 174 deletions(-)

diff --git a/ksrc/arch/arm/hal.c b/ksrc/arch/arm/hal.c
index 7b93d5d..ffd33e7 100644
--- a/ksrc/arch/arm/hal.c
+++ b/ksrc/arch/arm/hal.c
@@ -2,7 +2,7 @@
  *   @ingroup hal
  *   @file
  *
- *   Adeos-based Real-Time Abstraction Layer for PowerPC.
+ *   Adeos-based Real-Time Abstraction Layer for ARM.
  *
  *   ARM port
  *     Copyright (C) 2005 Stelian Pop
@@ -49,142 +49,78 @@
 #endif /* CONFIG_PROC_FS */
 #include <stdarg.h>
 
-static struct {
-    unsigned long flags;
-    int count;
-} rthal_linux_irq[IPIPE_NR_XIRQS];
-
 rthal_u32frac_t rthal_tsc_to_timer;
 EXPORT_SYMBOL(rthal_tsc_to_timer);
 
-enum rthal_ktimer_mode rthal_ktimer_saved_mode;
-
-int rthal_timer_request(void (*handler)(void),
-#ifdef CONFIG_GENERIC_CLOCKEVENTS
-                       void (*mode_emul)(enum clock_event_mode mode,
-                                         struct clock_event_device *cdev),
-                       int (*tick_emul)(unsigned long delay,
-                                        struct clock_event_device *cdev),
-#endif /* CONFIG_GENERIC_CLOCKEVENTS */
-                       int cpu)
-{
-    int tickval, err;
-    unsigned long flags;
-
-#ifdef CONFIG_GENERIC_CLOCKEVENTS
-    unsigned long dummy, *tmfreq = &dummy;
-    int res;
-
-    if (rthal_timerfreq_arg == 0)
-       tmfreq = &rthal_tunables.timer_freq;
-
-    res = ipipe_request_tickdev(RTHAL_TIMER_DEVICE, mode_emul,
-                               tick_emul, cpu, tmfreq);
-
-    switch (res) {
-    case CLOCK_EVT_MODE_PERIODIC:
-               /* oneshot tick emulation callback won't be used, ask
-                * the caller to start an internal timer for emulating
-                * a periodic tick. */
-           tickval = 1000000000UL / HZ;
-           break;
-
-    case CLOCK_EVT_MODE_ONESHOT:
-           /* oneshot tick emulation */
-           tickval = 1;
-           break;
-
-    case CLOCK_EVT_MODE_UNUSED:
-           /* we don't need to emulate the tick at all. */
-           tickval = 0;
-           break;
-
-    case CLOCK_EVT_MODE_SHUTDOWN:
-               return -ENOSYS;
-
-    default:
-           return res;
-    }
-    rthal_ktimer_saved_mode = res;
-#else /* !CONFIG_GENERIC_CLOCKEVENTS */
-    tickval = 1000000000UL / HZ;
-    rthal_ktimer_saved_mode = KTIMER_MODE_PERIODIC;
-
-    if (rthal_timerfreq_arg == 0)
-           rthal_tunables.timer_freq = CLOCK_TICK_RATE;
-#endif /* !CONFIG_GENERIC_CLOCKEVENTS */
-
-    flags = rthal_critical_enter(NULL);
-
-    __ipipe_mach_timerstolen = 1;
-
-    rthal_timer_program_shot(__ipipe_mach_ticks_per_jiffy);
+#define RTHAL_CALIBRATE_LOOPS 10
 
-    rthal_irq_release(RTHAL_TIMER_IRQ);
+static struct {
+       unsigned long flags;
+       int count;
+} rthal_linux_irq[IPIPE_NR_XIRQS];
 
-    err = rthal_irq_request(RTHAL_TIMER_IRQ,
-                           (rthal_irq_handler_t) handler, NULL, NULL);
+enum rthal_ktimer_mode rthal_ktimer_saved_mode;
 
-    rthal_critical_exit(flags);
+#define RTHAL_SET_ONESHOT_XENOMAI      1
+#define RTHAL_SET_ONESHOT_LINUX                2
+#define RTHAL_SET_PERIODIC             3
 
-    return err ?: tickval;
+static inline void steal_timer(int stolen)
+{
+       /*
+        * Some platform-specific I-pipe bits may want to know whether
+        * non-vanilla kernel code is currently fiddling with the
+        * timer chip; setting this flag on tells them so.
+        */
+       __ipipe_mach_timerstolen = stolen;
 }
 
-void rthal_timer_release(int cpu)
+static inline void force_oneshot_hw_mode(void)
 {
-    unsigned long flags;
-
-#ifdef CONFIG_GENERIC_CLOCKEVENTS
-    ipipe_release_tickdev(cpu);
-#endif
-
-    flags = rthal_critical_enter(NULL);
-
-    __ipipe_mach_release_timer();
-
-    rthal_irq_release(RTHAL_TIMER_IRQ);
-
-    __ipipe_mach_timerstolen = 0;
-
-    rthal_critical_exit(flags);
+       /*
+        * Program next tick ahead at a sensible date. We expect
+        * __ipipe_mach_set_dec() to switch off any auto-reload mode
+        * if that makes sense for the hardware.
+        */
+       __ipipe_mach_set_dec(__ipipe_mach_ticks_per_jiffy);
 }
 
-#ifdef CONFIG_GENERIC_CLOCKEVENTS
-void rthal_timer_notify_switch(enum clock_event_mode mode,
-                              struct clock_event_device *cdev)
+static inline void restore_normal_hw_mode(void)
 {
-       rthal_ktimer_saved_mode = mode;
+       steal_timer(0);
+       /*
+        * Ask the I-pipe to reset the normal timer operating mode at
+        * hardware level, which should match the current logical mode
+        * for the active clockevent.
+        */
+       __ipipe_mach_release_timer();
 }
 
-EXPORT_SYMBOL(rthal_timer_notify_switch);
-#endif
-
-#define RTHAL_CALIBRATE_LOOPS 10
-
 unsigned long rthal_timer_calibrate(void)
 {
-       unsigned long long next_shot = 0, start, end, sum = 0, sum_sq = 0;
+       unsigned long long start, end, sum = 0, sum_sq = 0;
        volatile unsigned const_delay = 0xffffffff;
+       unsigned int delay = const_delay, diff;
        unsigned long result, flags, tsc_lat;
-       unsigned delay = const_delay;
-       unsigned diff;
        int i, j;
 
        flags = rthal_critical_enter(NULL);
 
+       /*
+        * Hw interrupts off, other CPUs quiesced, no migration
+        * possible. We can now fiddle with the timer chip (per-cpu
+        * local or global, rthal_timer_program_shot() will handle
+        * this transparently via the I-pipe).
+        */
+       steal_timer(1);
+       force_oneshot_hw_mode();
+
        rthal_read_tsc(start);
        barrier();
        rthal_read_tsc(end);
        tsc_lat = end - start;
        barrier();
 
-       if (__ipipe_mach_timerstolen) {
-               rthal_read_tsc(next_shot);
-               next_shot += rthal_imuldiv(__ipipe_mach_get_dec(),
-                                          RTHAL_CLOCK_FREQ, RTHAL_TIMER_FREQ);
-               next_shot -= tsc_lat;
-       }
-
        for (i = 0; i < RTHAL_CALIBRATE_LOOPS; i++) {
                flush_cache_all();
                for (j = 0; j < RTHAL_CALIBRATE_LOOPS; j++) {
@@ -195,20 +131,12 @@ unsigned long rthal_timer_calibrate(void)
                        barrier();
                        rthal_read_tsc(end);
                        diff = end - start - tsc_lat;
-
                        sum += diff;
                        sum_sq += diff * diff;
                }
        }
 
-       if (__ipipe_mach_timerstolen) {
-               delay = (next_shot > end
-                        ? rthal_nodiv_imuldiv_ceil(next_shot - end,
-                                                   rthal_tsc_to_timer)
-                        : 0);
-               rthal_timer_program_shot(delay);
-       } else
-               __ipipe_mach_release_timer();
+       restore_normal_hw_mode();
 
        rthal_critical_exit(flags);
 
@@ -216,79 +144,273 @@ unsigned long rthal_timer_calibrate(void)
        do_div(sum, RTHAL_CALIBRATE_LOOPS * RTHAL_CALIBRATE_LOOPS);
        do_div(sum_sq, RTHAL_CALIBRATE_LOOPS * RTHAL_CALIBRATE_LOOPS);
        result = sum + int_sqrt(sum_sq - sum * sum) + 1;
+
        return result;
 }
 
+#ifdef CONFIG_SMP
+static void rthal_critical_sync(void)
+{
+       switch (rthal_sync_op) {
+       case RTHAL_SET_ONESHOT_XENOMAI:
+               force_oneshot_hw_mode();
+               steal_timer(1);
+               break;
+
+       case RTHAL_SET_ONESHOT_LINUX:
+               force_oneshot_hw_mode();
+               steal_timer(0);
+               /* We need to keep the timing cycle alive for the kernel. */
+               rthal_trigger_irq(RTHAL_TIMER_IRQ);
+               break;
+
+       case RTHAL_SET_PERIODIC:
+               restore_normal_hw_mode();
+               break;
+       }
+}
+#else /* CONFIG_SMP */
+#define rthal_critical_sync NULL
+#endif /* !CONFIG_SMP */
+
+static void rthal_timer_set_oneshot(int rt_mode)
+{
+       unsigned long flags;
+
+       flags = rthal_critical_enter(rthal_critical_sync);
+       if (rt_mode) {
+               rthal_sync_op = RTHAL_SET_ONESHOT_XENOMAI;
+               force_oneshot_hw_mode();
+               steal_timer(1);
+       } else {
+               rthal_sync_op = RTHAL_SET_ONESHOT_LINUX;
+               force_oneshot_hw_mode();
+               steal_timer(0);
+               /* We need to keep the timing cycle alive for the kernel. */
+               rthal_trigger_irq(RTHAL_TIMER_IRQ);
+       }
+       rthal_critical_exit(flags);
+}
+
+static void rthal_timer_set_periodic(void)
+{
+       unsigned long flags;
+
+       flags = rthal_critical_enter(rthal_critical_sync);
+       rthal_sync_op = RTHAL_SET_PERIODIC;
+       restore_normal_hw_mode();
+       rthal_critical_exit(flags);
+}
+
+static int cpu_timers_requested;
+
+#ifdef CONFIG_GENERIC_CLOCKEVENTS
+
+int rthal_timer_request(
+       void (*tick_handler)(void),
+       void (*mode_emul)(enum clock_event_mode mode,
+                         struct clock_event_device *cdev),
+       int (*tick_emul)(unsigned long delay,
+                        struct clock_event_device *cdev),
+       int cpu)
+{
+       unsigned long dummy, *tmfreq = &dummy;
+       int tickval, ret;
+
+       if (rthal_timerfreq_arg == 0)
+               tmfreq = &rthal_tunables.timer_freq;
+
+       ret = ipipe_request_tickdev(RTHAL_TIMER_DEVICE, mode_emul, tick_emul, 
cpu,
+                                   tmfreq);
+       switch (ret) {
+       case CLOCK_EVT_MODE_PERIODIC:
+               /* oneshot tick emulation callback won't be used, ask
+                * the caller to start an internal timer for emulating
+                * a periodic tick. */
+               tickval = 1000000000UL / HZ;
+               break;
+
+       case CLOCK_EVT_MODE_ONESHOT:
+               /* oneshot tick emulation */
+               tickval = 1;
+               break;
+
+       case CLOCK_EVT_MODE_UNUSED:
+               /* we don't need to emulate the tick at all. */
+               tickval = 0;
+               break;
+
+       case CLOCK_EVT_MODE_SHUTDOWN:
+               return -ENODEV;
+
+       default:
+               return ret;
+       }
+
+       rthal_ktimer_saved_mode = ret;
+
+       /*
+        * The rest of the initialization should only be performed
+        * once by a single CPU.
+        */
+       if (cpu_timers_requested++ > 0)
+               goto out;
+
+       ret = rthal_irq_request(RTHAL_TIMER_IRQ,
+                               (rthal_irq_handler_t)tick_handler,
+                               NULL, NULL);
+       if (ret)
+               return ret;
+
+       rthal_timer_set_oneshot(1);
+out:
+       return tickval;
+}
+
+void rthal_timer_release(int cpu)
+{
+       ipipe_release_tickdev(cpu);
+
+       if (--cpu_timers_requested > 0)
+               return;
+
+       rthal_irq_release(RTHAL_TIMER_IRQ);
+
+       if (rthal_ktimer_saved_mode == KTIMER_MODE_PERIODIC)
+               rthal_timer_set_periodic();
+       else if (rthal_ktimer_saved_mode == KTIMER_MODE_ONESHOT)
+               rthal_timer_set_oneshot(0);
+}
+
+void rthal_timer_notify_switch(enum clock_event_mode mode,
+                              struct clock_event_device *cdev)
+{
+       if (rthal_processor_id() > 0)
+               /*
+                * We assume all CPUs switch the same way, so we only
+                * track mode switches from the boot CPU.
+                */
+               return;
+
+       rthal_ktimer_saved_mode = mode;
+}
+EXPORT_SYMBOL(rthal_timer_notify_switch);
+
+#else /* !CONFIG_GENERIC_CLOCKEVENTS */
+
+int rthal_timer_request(void (*handler)(void), int cpu)
+{
+       int ret;
+
+       /*
+        * The rest of the initialization should only be performed
+        * once by a single CPU.
+        */
+       if (cpu_timers_requested++ > 0)
+               return 0;
+
+       rthal_ktimer_saved_mode = KTIMER_MODE_PERIODIC;
+
+       if (rthal_timerfreq_arg == 0)
+               rthal_tunables.timer_freq = rthal_cpufreq_arg;
+
+       ret = rthal_irq_request(RTHAL_TIMER_IRQ,
+                               (rthal_irq_handler_t) handler,
+                               NULL, NULL);
+       if (ret)
+               return ret;
+
+       rthal_timer_set_oneshot(1);
+
+       return 0;
+}
+
+void rthal_timer_release(int cpu)
+{
+       if (--cpu_timers_requested > 0)
+               return;
+
+       rthal_irq_release(RTHAL_TIMER_IRQ);
+       rthal_timer_set_periodic();
+}
+
+#endif /* !CONFIG_GENERIC_CLOCKEVENTS */
+
 int rthal_irq_host_request(unsigned irq,
-                          rthal_irq_host_handler_t handler,
-                          char *name, void *dev_id)
+                           rthal_irq_host_handler_t handler,
+                           char *name, void *dev_id)
 {
-    unsigned long flags;
+       unsigned long flags;
 
-    if (irq >= IPIPE_NR_XIRQS ||
-       handler == NULL ||
-       rthal_irq_descp(irq) == NULL)
-      return -EINVAL;
+       if (irq >= IPIPE_NR_XIRQS ||
+           handler == NULL ||
+           rthal_irq_descp(irq) == NULL)
+               return -EINVAL;
 
-    rthal_irqdesc_lock(irq, flags);
+       rthal_irqdesc_lock(irq, flags);
 
-    if (rthal_linux_irq[irq].count++ == 0 && rthal_irq_descp(irq)->action) {
-       rthal_linux_irq[irq].flags = rthal_irq_descp(irq)->action->flags;
-       rthal_irq_descp(irq)->action->flags |= IRQF_SHARED;
-    }
+       if (rthal_linux_irq[irq].count++ == 0 && rthal_irq_descp(irq)->action) {
+               rthal_linux_irq[irq].flags = 
rthal_irq_descp(irq)->action->flags;
+               rthal_irq_descp(irq)->action->flags |= IRQF_SHARED;
+       }
 
-    rthal_irqdesc_unlock(irq, flags);
+       rthal_irqdesc_unlock(irq, flags);
 
-    return request_irq(irq, handler, IRQF_SHARED, name, dev_id);
+       return request_irq(irq, handler, IRQF_SHARED, name, dev_id);
 }
 
 int rthal_irq_host_release(unsigned irq, void *dev_id)
 {
-    unsigned long flags;
+       unsigned long flags;
 
-    if (irq >= IPIPE_NR_XIRQS ||
-       rthal_linux_irq[irq].count == 0 ||
-       rthal_irq_descp(irq) == NULL)
-      return -EINVAL;
+       if (irq >= IPIPE_NR_XIRQS ||
+           rthal_linux_irq[irq].count == 0 ||
+           rthal_irq_descp(irq) == NULL)
+               return -EINVAL;
 
-    free_irq(irq, dev_id);
+       free_irq(irq, dev_id);
 
-    rthal_irqdesc_lock(irq, flags);
+       rthal_irqdesc_lock(irq, flags);
 
-    if (--rthal_linux_irq[irq].count == 0 && rthal_irq_descp(irq)->action)
-       rthal_irq_descp(irq)->action->flags = rthal_linux_irq[irq].flags;
+       if (--rthal_linux_irq[irq].count == 0 && rthal_irq_descp(irq)->action)
+               rthal_irq_descp(irq)->action->flags = 
rthal_linux_irq[irq].flags;
 
-    rthal_irqdesc_unlock(irq, flags);
+       rthal_irqdesc_unlock(irq, flags);
 
-    return 0;
+       return 0;
 }
 
-int rthal_irq_enable(unsigned irq)
+int rthal_irq_enable(unsigned int irq)
 {
-    if (irq >= IPIPE_NR_XIRQS || rthal_irq_descp(irq) == NULL)
-       return -EINVAL;
+       if (irq >= IPIPE_NR_XIRQS || rthal_irq_descp(irq) == NULL)
+               return -EINVAL;
+
+       /*
+        * We don't care of disable nesting level: real-time IRQ
+        * channels are not meant to be shared with the regular
+        * kernel.
+        */
+       rthal_mark_irq_enabled(irq);
 
-    /* We don't care of disable nesting level: real-time IRQ channels
-       are not meant to be shared with the regular kernel. */
-    rthal_mark_irq_enabled(irq);
-    return rthal_irq_chip_enable(irq);
+       return rthal_irq_chip_enable(irq);
 }
 
-int rthal_irq_disable(unsigned irq)
+int rthal_irq_disable(unsigned int irq)
 {
-    if (irq >= IPIPE_NR_XIRQS || rthal_irq_descp(irq) == NULL)
-       return -EINVAL;
+       if (irq >= IPIPE_NR_XIRQS || rthal_irq_descp(irq) == NULL)
+               return -EINVAL;
 
-    rthal_mark_irq_disabled(irq);
-    return rthal_irq_chip_disable(irq);
+       rthal_mark_irq_disabled(irq);
+
+       return rthal_irq_chip_disable(irq);
 }
 
-int rthal_irq_end(unsigned irq)
+int rthal_irq_end(unsigned int irq)
 {
-    if (irq >= IPIPE_NR_XIRQS || rthal_irq_descp(irq) == NULL)
-       return -EINVAL;
+       if (irq >= IPIPE_NR_XIRQS || rthal_irq_descp(irq) == NULL)
+               return -EINVAL;
 
-    return rthal_irq_chip_end(irq);
+       return rthal_irq_chip_end(irq);
 }
 
 void __rthal_arm_fault_range(struct vm_area_struct *vma)
@@ -300,28 +422,28 @@ void __rthal_arm_fault_range(struct vm_area_struct *vma)
 
 static inline int do_exception_event(unsigned event, unsigned domid, void 
*data)
 {
-    if (domid == RTHAL_DOMAIN_ID) {
-           rthal_realtime_faults[rthal_processor_id()][event]++;
+       if (domid == RTHAL_DOMAIN_ID) {
+               rthal_realtime_faults[rthal_processor_id()][event]++;
 
-           if (rthal_trap_handler != NULL &&
-               rthal_trap_handler(event, domid, data) != 0)
-                   return RTHAL_EVENT_STOP;
-    }
+               if (rthal_trap_handler != NULL &&
+                   rthal_trap_handler(event, domid, data) != 0)
+                       return RTHAL_EVENT_STOP;
+       }
 
-    return RTHAL_EVENT_PROPAGATE;
+       return RTHAL_EVENT_PROPAGATE;
 }
 
 RTHAL_DECLARE_EVENT(exception_event);
 
 static inline void do_rthal_domain_entry(void)
 {
-    unsigned trapnr;
+       unsigned trapnr;
 
-    /* Trap all faults. */
-    for (trapnr = 0; trapnr < RTHAL_NR_FAULTS; trapnr++)
-       rthal_catch_exception(trapnr, &exception_event);
+       /* Trap all faults. */
+       for (trapnr = 0; trapnr < RTHAL_NR_FAULTS; trapnr++)
+               rthal_catch_exception(trapnr, &exception_event);
 
-    printk(KERN_INFO "Xenomai: hal/arm started.\n");
+       printk(KERN_INFO "Xenomai: hal/arm started.\n");
 }
 
 RTHAL_DECLARE_DOMAIN(rthal_domain_entry);
@@ -345,8 +467,8 @@ int rthal_arch_init(void)
 
 void rthal_arch_cleanup(void)
 {
-    /* Nothing to cleanup so far. */
-    printk(KERN_INFO "Xenomai: hal/arm stopped.\n");
+       /* Nothing to cleanup so far. */
+       printk(KERN_INFO "Xenomai: hal/arm stopped.\n");
 }
 
 /*...@}*/
@@ -361,5 +483,3 @@ EXPORT_SYMBOL(last_VFP_context);
 EXPORT_SYMBOL(rthal_vfp_save);
 EXPORT_SYMBOL(rthal_vfp_load);
 #endif /* CONFIG_VFP && CONFIG_XENO_HW_FPU */
-
-// vim: ts=4 et sw=4 sts=4


_______________________________________________
Xenomai-git mailing list
Xenomai-git@gna.org
https://mail.gna.org/listinfo/xenomai-git

Reply via email to