/*
|
* SPDX-License-Identifier: GPL-2.0
|
*
|
* Copyright (C) 2001,2002,2003,2007,2012 Philippe Gerum <rpm@xenomai.org>.
|
* Copyright (C) 2004 Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
|
*/
|
|
#include <linux/tick.h>
|
#include <linux/clockchips.h>
|
#include <cobalt/kernel/intr.h>
|
#include <pipeline/tick.h>
|
#include <cobalt/kernel/sched.h>
|
#include <cobalt/kernel/timer.h>
|
|
static DEFINE_PER_CPU(struct clock_proxy_device *, proxy_device);
|
|
const char *pipeline_timer_name(void)
|
{
|
struct clock_proxy_device *dev = per_cpu(proxy_device, 0);
|
struct clock_event_device *real_dev = dev->real_device;
|
|
/*
|
* Return the name of the current clock event chip, which is
|
* the real device controlled by the proxy tick device.
|
*/
|
return real_dev->name;
|
}
|
|
void pipeline_set_timer_shot(unsigned long delay) /* ns */
|
{
|
struct clock_proxy_device *dev = __this_cpu_read(proxy_device);
|
struct clock_event_device *real_dev = dev->real_device;
|
u64 cycles;
|
ktime_t t;
|
int ret;
|
|
if (real_dev->features & CLOCK_EVT_FEAT_KTIME) {
|
t = ktime_add(delay, xnclock_core_read_raw());
|
real_dev->set_next_ktime(t, real_dev);
|
} else {
|
if (delay <= 0) {
|
delay = real_dev->min_delta_ns;
|
} else {
|
delay = min_t(int64_t, delay,
|
real_dev->max_delta_ns);
|
delay = max_t(int64_t, delay,
|
real_dev->min_delta_ns);
|
}
|
cycles = ((u64)delay * real_dev->mult) >> real_dev->shift;
|
ret = real_dev->set_next_event(cycles, real_dev);
|
if (ret)
|
real_dev->set_next_event(real_dev->min_delta_ticks,
|
real_dev);
|
}
|
}
|
|
static int proxy_set_next_ktime(ktime_t expires,
|
struct clock_event_device *proxy_dev) /* hard irqs on/off */
|
{
|
struct xnsched *sched;
|
unsigned long flags;
|
ktime_t delta;
|
int ret;
|
|
/*
|
* Expiration dates of in-band timers are based on the common
|
* monotonic time base. If the timeout date has already
|
* elapsed, make sure xntimer_start() does not fail with
|
* -ETIMEDOUT but programs the hardware for ticking
|
* immediately instead.
|
*/
|
delta = ktime_sub(expires, ktime_get());
|
if (delta < 0)
|
delta = 0;
|
|
xnlock_get_irqsave(&nklock, flags);
|
sched = xnsched_current();
|
ret = xntimer_start(&sched->htimer, delta, XN_INFINITE, XN_RELATIVE);
|
xnlock_put_irqrestore(&nklock, flags);
|
|
return ret ? -ETIME : 0;
|
}
|
|
bool pipeline_must_force_program_tick(struct xnsched *sched)
|
{
|
return sched->lflags & XNTSTOP;
|
}
|
|
static int proxy_set_oneshot_stopped(struct clock_event_device *proxy_dev)
|
{
|
struct clock_event_device *real_dev;
|
struct clock_proxy_device *dev;
|
struct xnsched *sched;
|
spl_t s;
|
|
dev = container_of(proxy_dev, struct clock_proxy_device, proxy_device);
|
|
/*
|
* In-band wants to disable the clock hardware on entering a
|
* tickless state, so we have to stop our in-band tick
|
* emulation. Propagate the request for shutting down the
|
* hardware to the real device only if we have no outstanding
|
* OOB timers. CAUTION: the in-band timer is counted when
|
* assessing the RQ_IDLE condition, so we need to stop it
|
* prior to testing the latter.
|
*/
|
xnlock_get_irqsave(&nklock, s);
|
sched = xnsched_current();
|
xntimer_stop(&sched->htimer);
|
sched->lflags |= XNTSTOP;
|
|
if (sched->lflags & XNIDLE) {
|
real_dev = dev->real_device;
|
real_dev->set_state_oneshot_stopped(real_dev);
|
}
|
|
xnlock_put_irqrestore(&nklock, s);
|
|
return 0;
|
}
|
|
static void setup_proxy(struct clock_proxy_device *dev)
|
{
|
struct clock_event_device *proxy_dev = &dev->proxy_device;
|
|
dev->handle_oob_event = (typeof(dev->handle_oob_event))
|
xnintr_core_clock_handler;
|
proxy_dev->features |= CLOCK_EVT_FEAT_KTIME;
|
proxy_dev->set_next_ktime = proxy_set_next_ktime;
|
if (proxy_dev->set_state_oneshot_stopped)
|
proxy_dev->set_state_oneshot_stopped = proxy_set_oneshot_stopped;
|
__this_cpu_write(proxy_device, dev);
|
}
|
|
#ifdef CONFIG_SMP
|
static irqreturn_t tick_ipi_handler(int irq, void *dev_id)
|
{
|
xnintr_core_clock_handler();
|
|
return IRQ_HANDLED;
|
}
|
#endif
|
|
int pipeline_install_tick_proxy(void)
|
{
|
int ret;
|
|
#ifdef CONFIG_SMP
|
/*
|
* We may be running a SMP kernel on a uniprocessor machine
|
* whose interrupt controller provides no IPI: attempt to hook
|
* the timer IPI only if the hardware can support multiple
|
* CPUs.
|
*/
|
if (num_possible_cpus() > 1) {
|
ret = __request_percpu_irq(TIMER_OOB_IPI,
|
tick_ipi_handler,
|
IRQF_OOB, "Xenomai timer IPI",
|
&cobalt_machine_cpudata);
|
if (ret)
|
return ret;
|
}
|
#endif
|
|
/* Install the proxy tick device */
|
ret = tick_install_proxy(setup_proxy, &xnsched_realtime_cpus);
|
if (ret)
|
goto fail_proxy;
|
|
return 0;
|
|
fail_proxy:
|
#ifdef CONFIG_SMP
|
if (num_possible_cpus() > 1)
|
free_percpu_irq(TIMER_OOB_IPI, &cobalt_machine_cpudata);
|
#endif
|
|
return ret;
|
}
|
|
void pipeline_uninstall_tick_proxy(void)
|
{
|
/* Uninstall the proxy tick device. */
|
tick_uninstall_proxy(&xnsched_realtime_cpus);
|
|
#ifdef CONFIG_SMP
|
if (num_possible_cpus() > 1)
|
free_percpu_irq(TIMER_OOB_IPI, &cobalt_machine_cpudata);
|
#endif
|
}
|
