![Felipe Balbi 2](/assets/img/avatar_default.png)
The scheduler imposes a requirement to sched_clock() which is to stop the clock during suspend, if we don't do that any RT thread will be rescheduled in the future which might cause any sort of problems. This became an issue on OMAP when we converted omap-i2c.c to use threaded IRQs, it turned out that depending on how much time we spent on suspend, the I2C IRQ thread would end up being rescheduled so far in the future that I2C transfers would timeout and, because omap_hsmmc depends on an I2C-connected device to detect if an MMC card is inserted in the slot, our rootfs would just vanish. arch/arm/kernel/sched_clock.c already had an optional implementation (sched_clock_needs_suspend()) which would handle scheduler's requirement properly, what this patch does is simply to make that implementation non-optional. Note that this has the side-effect that printk timings won't reflect the actual time spent on suspend so other methods to measure that will have to be used. This has been tested with beagleboard XM (OMAP3630) and pandaboard rev A3 (OMAP4430). Suspend to RAM is now working after this patch. Thanks to Kevin Hilman for helping out with debugging. Acked-by: Kevin Hilman <khilman@ti.com> Acked-by: Linus Walleij <linus.walleij@linaro.org> Signed-off-by: Felipe Balbi <balbi@ti.com> Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
207 lines
4.8 KiB
C
207 lines
4.8 KiB
C
/*
|
|
* sched_clock.c: support for extending counters to full 64-bit ns counter
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
#include <linux/clocksource.h>
|
|
#include <linux/init.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/syscore_ops.h>
|
|
#include <linux/timer.h>
|
|
|
|
#include <asm/sched_clock.h>
|
|
|
|
struct clock_data {
|
|
u64 epoch_ns;
|
|
u32 epoch_cyc;
|
|
u32 epoch_cyc_copy;
|
|
u32 mult;
|
|
u32 shift;
|
|
bool suspended;
|
|
bool needs_suspend;
|
|
};
|
|
|
|
static void sched_clock_poll(unsigned long wrap_ticks);
|
|
static DEFINE_TIMER(sched_clock_timer, sched_clock_poll, 0, 0);
|
|
static int irqtime = -1;
|
|
|
|
core_param(irqtime, irqtime, int, 0400);
|
|
|
|
static struct clock_data cd = {
|
|
.mult = NSEC_PER_SEC / HZ,
|
|
};
|
|
|
|
static u32 __read_mostly sched_clock_mask = 0xffffffff;
|
|
|
|
static u32 notrace jiffy_sched_clock_read(void)
|
|
{
|
|
return (u32)(jiffies - INITIAL_JIFFIES);
|
|
}
|
|
|
|
static u32 __read_mostly (*read_sched_clock)(void) = jiffy_sched_clock_read;
|
|
|
|
static inline u64 cyc_to_ns(u64 cyc, u32 mult, u32 shift)
|
|
{
|
|
return (cyc * mult) >> shift;
|
|
}
|
|
|
|
static unsigned long long cyc_to_sched_clock(u32 cyc, u32 mask)
|
|
{
|
|
u64 epoch_ns;
|
|
u32 epoch_cyc;
|
|
|
|
if (cd.suspended)
|
|
return cd.epoch_ns;
|
|
|
|
/*
|
|
* Load the epoch_cyc and epoch_ns atomically. We do this by
|
|
* ensuring that we always write epoch_cyc, epoch_ns and
|
|
* epoch_cyc_copy in strict order, and read them in strict order.
|
|
* If epoch_cyc and epoch_cyc_copy are not equal, then we're in
|
|
* the middle of an update, and we should repeat the load.
|
|
*/
|
|
do {
|
|
epoch_cyc = cd.epoch_cyc;
|
|
smp_rmb();
|
|
epoch_ns = cd.epoch_ns;
|
|
smp_rmb();
|
|
} while (epoch_cyc != cd.epoch_cyc_copy);
|
|
|
|
return epoch_ns + cyc_to_ns((cyc - epoch_cyc) & mask, cd.mult, cd.shift);
|
|
}
|
|
|
|
/*
|
|
* Atomically update the sched_clock epoch.
|
|
*/
|
|
static void notrace update_sched_clock(void)
|
|
{
|
|
unsigned long flags;
|
|
u32 cyc;
|
|
u64 ns;
|
|
|
|
cyc = read_sched_clock();
|
|
ns = cd.epoch_ns +
|
|
cyc_to_ns((cyc - cd.epoch_cyc) & sched_clock_mask,
|
|
cd.mult, cd.shift);
|
|
/*
|
|
* Write epoch_cyc and epoch_ns in a way that the update is
|
|
* detectable in cyc_to_fixed_sched_clock().
|
|
*/
|
|
raw_local_irq_save(flags);
|
|
cd.epoch_cyc = cyc;
|
|
smp_wmb();
|
|
cd.epoch_ns = ns;
|
|
smp_wmb();
|
|
cd.epoch_cyc_copy = cyc;
|
|
raw_local_irq_restore(flags);
|
|
}
|
|
|
|
static void sched_clock_poll(unsigned long wrap_ticks)
|
|
{
|
|
mod_timer(&sched_clock_timer, round_jiffies(jiffies + wrap_ticks));
|
|
update_sched_clock();
|
|
}
|
|
|
|
void __init setup_sched_clock(u32 (*read)(void), int bits, unsigned long rate)
|
|
{
|
|
unsigned long r, w;
|
|
u64 res, wrap;
|
|
char r_unit;
|
|
|
|
BUG_ON(bits > 32);
|
|
WARN_ON(!irqs_disabled());
|
|
WARN_ON(read_sched_clock != jiffy_sched_clock_read);
|
|
read_sched_clock = read;
|
|
sched_clock_mask = (1 << bits) - 1;
|
|
|
|
/* calculate the mult/shift to convert counter ticks to ns. */
|
|
clocks_calc_mult_shift(&cd.mult, &cd.shift, rate, NSEC_PER_SEC, 0);
|
|
|
|
r = rate;
|
|
if (r >= 4000000) {
|
|
r /= 1000000;
|
|
r_unit = 'M';
|
|
} else if (r >= 1000) {
|
|
r /= 1000;
|
|
r_unit = 'k';
|
|
} else
|
|
r_unit = ' ';
|
|
|
|
/* calculate how many ns until we wrap */
|
|
wrap = cyc_to_ns((1ULL << bits) - 1, cd.mult, cd.shift);
|
|
do_div(wrap, NSEC_PER_MSEC);
|
|
w = wrap;
|
|
|
|
/* calculate the ns resolution of this counter */
|
|
res = cyc_to_ns(1ULL, cd.mult, cd.shift);
|
|
pr_info("sched_clock: %u bits at %lu%cHz, resolution %lluns, wraps every %lums\n",
|
|
bits, r, r_unit, res, w);
|
|
|
|
/*
|
|
* Start the timer to keep sched_clock() properly updated and
|
|
* sets the initial epoch.
|
|
*/
|
|
sched_clock_timer.data = msecs_to_jiffies(w - (w / 10));
|
|
update_sched_clock();
|
|
|
|
/*
|
|
* Ensure that sched_clock() starts off at 0ns
|
|
*/
|
|
cd.epoch_ns = 0;
|
|
|
|
/* Enable IRQ time accounting if we have a fast enough sched_clock */
|
|
if (irqtime > 0 || (irqtime == -1 && rate >= 1000000))
|
|
enable_sched_clock_irqtime();
|
|
|
|
pr_debug("Registered %pF as sched_clock source\n", read);
|
|
}
|
|
|
|
unsigned long long notrace sched_clock(void)
|
|
{
|
|
u32 cyc = read_sched_clock();
|
|
return cyc_to_sched_clock(cyc, sched_clock_mask);
|
|
}
|
|
|
|
void __init sched_clock_postinit(void)
|
|
{
|
|
/*
|
|
* If no sched_clock function has been provided at that point,
|
|
* make it the final one one.
|
|
*/
|
|
if (read_sched_clock == jiffy_sched_clock_read)
|
|
setup_sched_clock(jiffy_sched_clock_read, 32, HZ);
|
|
|
|
sched_clock_poll(sched_clock_timer.data);
|
|
}
|
|
|
|
static int sched_clock_suspend(void)
|
|
{
|
|
sched_clock_poll(sched_clock_timer.data);
|
|
cd.suspended = true;
|
|
return 0;
|
|
}
|
|
|
|
static void sched_clock_resume(void)
|
|
{
|
|
cd.epoch_cyc = read_sched_clock();
|
|
cd.epoch_cyc_copy = cd.epoch_cyc;
|
|
cd.suspended = false;
|
|
}
|
|
|
|
static struct syscore_ops sched_clock_ops = {
|
|
.suspend = sched_clock_suspend,
|
|
.resume = sched_clock_resume,
|
|
};
|
|
|
|
static int __init sched_clock_syscore_init(void)
|
|
{
|
|
register_syscore_ops(&sched_clock_ops);
|
|
return 0;
|
|
}
|
|
device_initcall(sched_clock_syscore_init);
|