mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-09 18:06:39 +07:00
da7e6f45c3
The broadcast framework can potentially be made use of by archs which do not have an external clock device as well. Then, it is required that one of the CPUs need to handle the broadcasting of wakeup IPIs to the CPUs in deep idle. As a result its local timers should remain functional all the time. For such a CPU, the BROADCAST_ENTER notification has to fail indicating that its clock device cannot be shutdown. To make way for this support, change the return type of tick_broadcast_oneshot_control() and hence clockevents_notify() to indicate such scenarios. Signed-off-by: Preeti U Murthy <preeti@linux.vnet.ibm.com> Cc: deepthi@linux.vnet.ibm.com Cc: paulmck@linux.vnet.ibm.com Cc: fweisbec@gmail.com Cc: paulus@samba.org Cc: srivatsa.bhat@linux.vnet.ibm.com Cc: svaidy@linux.vnet.ibm.com Cc: peterz@infradead.org Cc: benh@kernel.crashing.org Cc: rafael.j.wysocki@intel.com Cc: linuxppc-dev@lists.ozlabs.org Link: http://lkml.kernel.org/r/20140207080606.17187.78306.stgit@preeti.in.ibm.com Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
730 lines
18 KiB
C
730 lines
18 KiB
C
/*
|
|
* linux/kernel/time/clockevents.c
|
|
*
|
|
* This file contains functions which manage clock event devices.
|
|
*
|
|
* Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
|
|
* Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
|
|
* Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
|
|
*
|
|
* This code is licenced under the GPL version 2. For details see
|
|
* kernel-base/COPYING.
|
|
*/
|
|
|
|
#include <linux/clockchips.h>
|
|
#include <linux/hrtimer.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/smp.h>
|
|
#include <linux/device.h>
|
|
|
|
#include "tick-internal.h"
|
|
|
|
/* The registered clock event devices */
|
|
static LIST_HEAD(clockevent_devices);
|
|
static LIST_HEAD(clockevents_released);
|
|
/* Protection for the above */
|
|
static DEFINE_RAW_SPINLOCK(clockevents_lock);
|
|
/* Protection for unbind operations */
|
|
static DEFINE_MUTEX(clockevents_mutex);
|
|
|
|
struct ce_unbind {
|
|
struct clock_event_device *ce;
|
|
int res;
|
|
};
|
|
|
|
static u64 cev_delta2ns(unsigned long latch, struct clock_event_device *evt,
|
|
bool ismax)
|
|
{
|
|
u64 clc = (u64) latch << evt->shift;
|
|
u64 rnd;
|
|
|
|
if (unlikely(!evt->mult)) {
|
|
evt->mult = 1;
|
|
WARN_ON(1);
|
|
}
|
|
rnd = (u64) evt->mult - 1;
|
|
|
|
/*
|
|
* Upper bound sanity check. If the backwards conversion is
|
|
* not equal latch, we know that the above shift overflowed.
|
|
*/
|
|
if ((clc >> evt->shift) != (u64)latch)
|
|
clc = ~0ULL;
|
|
|
|
/*
|
|
* Scaled math oddities:
|
|
*
|
|
* For mult <= (1 << shift) we can safely add mult - 1 to
|
|
* prevent integer rounding loss. So the backwards conversion
|
|
* from nsec to device ticks will be correct.
|
|
*
|
|
* For mult > (1 << shift), i.e. device frequency is > 1GHz we
|
|
* need to be careful. Adding mult - 1 will result in a value
|
|
* which when converted back to device ticks can be larger
|
|
* than latch by up to (mult - 1) >> shift. For the min_delta
|
|
* calculation we still want to apply this in order to stay
|
|
* above the minimum device ticks limit. For the upper limit
|
|
* we would end up with a latch value larger than the upper
|
|
* limit of the device, so we omit the add to stay below the
|
|
* device upper boundary.
|
|
*
|
|
* Also omit the add if it would overflow the u64 boundary.
|
|
*/
|
|
if ((~0ULL - clc > rnd) &&
|
|
(!ismax || evt->mult <= (1U << evt->shift)))
|
|
clc += rnd;
|
|
|
|
do_div(clc, evt->mult);
|
|
|
|
/* Deltas less than 1usec are pointless noise */
|
|
return clc > 1000 ? clc : 1000;
|
|
}
|
|
|
|
/**
|
|
* clockevents_delta2ns - Convert a latch value (device ticks) to nanoseconds
|
|
* @latch: value to convert
|
|
* @evt: pointer to clock event device descriptor
|
|
*
|
|
* Math helper, returns latch value converted to nanoseconds (bound checked)
|
|
*/
|
|
u64 clockevent_delta2ns(unsigned long latch, struct clock_event_device *evt)
|
|
{
|
|
return cev_delta2ns(latch, evt, false);
|
|
}
|
|
EXPORT_SYMBOL_GPL(clockevent_delta2ns);
|
|
|
|
/**
|
|
* clockevents_set_mode - set the operating mode of a clock event device
|
|
* @dev: device to modify
|
|
* @mode: new mode
|
|
*
|
|
* Must be called with interrupts disabled !
|
|
*/
|
|
void clockevents_set_mode(struct clock_event_device *dev,
|
|
enum clock_event_mode mode)
|
|
{
|
|
if (dev->mode != mode) {
|
|
dev->set_mode(mode, dev);
|
|
dev->mode = mode;
|
|
|
|
/*
|
|
* A nsec2cyc multiplicator of 0 is invalid and we'd crash
|
|
* on it, so fix it up and emit a warning:
|
|
*/
|
|
if (mode == CLOCK_EVT_MODE_ONESHOT) {
|
|
if (unlikely(!dev->mult)) {
|
|
dev->mult = 1;
|
|
WARN_ON(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* clockevents_shutdown - shutdown the device and clear next_event
|
|
* @dev: device to shutdown
|
|
*/
|
|
void clockevents_shutdown(struct clock_event_device *dev)
|
|
{
|
|
clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
|
|
dev->next_event.tv64 = KTIME_MAX;
|
|
}
|
|
|
|
#ifdef CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST
|
|
|
|
/* Limit min_delta to a jiffie */
|
|
#define MIN_DELTA_LIMIT (NSEC_PER_SEC / HZ)
|
|
|
|
/**
|
|
* clockevents_increase_min_delta - raise minimum delta of a clock event device
|
|
* @dev: device to increase the minimum delta
|
|
*
|
|
* Returns 0 on success, -ETIME when the minimum delta reached the limit.
|
|
*/
|
|
static int clockevents_increase_min_delta(struct clock_event_device *dev)
|
|
{
|
|
/* Nothing to do if we already reached the limit */
|
|
if (dev->min_delta_ns >= MIN_DELTA_LIMIT) {
|
|
printk(KERN_WARNING "CE: Reprogramming failure. Giving up\n");
|
|
dev->next_event.tv64 = KTIME_MAX;
|
|
return -ETIME;
|
|
}
|
|
|
|
if (dev->min_delta_ns < 5000)
|
|
dev->min_delta_ns = 5000;
|
|
else
|
|
dev->min_delta_ns += dev->min_delta_ns >> 1;
|
|
|
|
if (dev->min_delta_ns > MIN_DELTA_LIMIT)
|
|
dev->min_delta_ns = MIN_DELTA_LIMIT;
|
|
|
|
printk(KERN_WARNING "CE: %s increased min_delta_ns to %llu nsec\n",
|
|
dev->name ? dev->name : "?",
|
|
(unsigned long long) dev->min_delta_ns);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* clockevents_program_min_delta - Set clock event device to the minimum delay.
|
|
* @dev: device to program
|
|
*
|
|
* Returns 0 on success, -ETIME when the retry loop failed.
|
|
*/
|
|
static int clockevents_program_min_delta(struct clock_event_device *dev)
|
|
{
|
|
unsigned long long clc;
|
|
int64_t delta;
|
|
int i;
|
|
|
|
for (i = 0;;) {
|
|
delta = dev->min_delta_ns;
|
|
dev->next_event = ktime_add_ns(ktime_get(), delta);
|
|
|
|
if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
|
|
return 0;
|
|
|
|
dev->retries++;
|
|
clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
|
|
if (dev->set_next_event((unsigned long) clc, dev) == 0)
|
|
return 0;
|
|
|
|
if (++i > 2) {
|
|
/*
|
|
* We tried 3 times to program the device with the
|
|
* given min_delta_ns. Try to increase the minimum
|
|
* delta, if that fails as well get out of here.
|
|
*/
|
|
if (clockevents_increase_min_delta(dev))
|
|
return -ETIME;
|
|
i = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#else /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */
|
|
|
|
/**
|
|
* clockevents_program_min_delta - Set clock event device to the minimum delay.
|
|
* @dev: device to program
|
|
*
|
|
* Returns 0 on success, -ETIME when the retry loop failed.
|
|
*/
|
|
static int clockevents_program_min_delta(struct clock_event_device *dev)
|
|
{
|
|
unsigned long long clc;
|
|
int64_t delta;
|
|
|
|
delta = dev->min_delta_ns;
|
|
dev->next_event = ktime_add_ns(ktime_get(), delta);
|
|
|
|
if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
|
|
return 0;
|
|
|
|
dev->retries++;
|
|
clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
|
|
return dev->set_next_event((unsigned long) clc, dev);
|
|
}
|
|
|
|
#endif /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */
|
|
|
|
/**
|
|
* clockevents_program_event - Reprogram the clock event device.
|
|
* @dev: device to program
|
|
* @expires: absolute expiry time (monotonic clock)
|
|
* @force: program minimum delay if expires can not be set
|
|
*
|
|
* Returns 0 on success, -ETIME when the event is in the past.
|
|
*/
|
|
int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,
|
|
bool force)
|
|
{
|
|
unsigned long long clc;
|
|
int64_t delta;
|
|
int rc;
|
|
|
|
if (unlikely(expires.tv64 < 0)) {
|
|
WARN_ON_ONCE(1);
|
|
return -ETIME;
|
|
}
|
|
|
|
dev->next_event = expires;
|
|
|
|
if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
|
|
return 0;
|
|
|
|
/* Shortcut for clockevent devices that can deal with ktime. */
|
|
if (dev->features & CLOCK_EVT_FEAT_KTIME)
|
|
return dev->set_next_ktime(expires, dev);
|
|
|
|
delta = ktime_to_ns(ktime_sub(expires, ktime_get()));
|
|
if (delta <= 0)
|
|
return force ? clockevents_program_min_delta(dev) : -ETIME;
|
|
|
|
delta = min(delta, (int64_t) dev->max_delta_ns);
|
|
delta = max(delta, (int64_t) dev->min_delta_ns);
|
|
|
|
clc = ((unsigned long long) delta * dev->mult) >> dev->shift;
|
|
rc = dev->set_next_event((unsigned long) clc, dev);
|
|
|
|
return (rc && force) ? clockevents_program_min_delta(dev) : rc;
|
|
}
|
|
|
|
/*
|
|
* Called after a notify add to make devices available which were
|
|
* released from the notifier call.
|
|
*/
|
|
static void clockevents_notify_released(void)
|
|
{
|
|
struct clock_event_device *dev;
|
|
|
|
while (!list_empty(&clockevents_released)) {
|
|
dev = list_entry(clockevents_released.next,
|
|
struct clock_event_device, list);
|
|
list_del(&dev->list);
|
|
list_add(&dev->list, &clockevent_devices);
|
|
tick_check_new_device(dev);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Try to install a replacement clock event device
|
|
*/
|
|
static int clockevents_replace(struct clock_event_device *ced)
|
|
{
|
|
struct clock_event_device *dev, *newdev = NULL;
|
|
|
|
list_for_each_entry(dev, &clockevent_devices, list) {
|
|
if (dev == ced || dev->mode != CLOCK_EVT_MODE_UNUSED)
|
|
continue;
|
|
|
|
if (!tick_check_replacement(newdev, dev))
|
|
continue;
|
|
|
|
if (!try_module_get(dev->owner))
|
|
continue;
|
|
|
|
if (newdev)
|
|
module_put(newdev->owner);
|
|
newdev = dev;
|
|
}
|
|
if (newdev) {
|
|
tick_install_replacement(newdev);
|
|
list_del_init(&ced->list);
|
|
}
|
|
return newdev ? 0 : -EBUSY;
|
|
}
|
|
|
|
/*
|
|
* Called with clockevents_mutex and clockevents_lock held
|
|
*/
|
|
static int __clockevents_try_unbind(struct clock_event_device *ced, int cpu)
|
|
{
|
|
/* Fast track. Device is unused */
|
|
if (ced->mode == CLOCK_EVT_MODE_UNUSED) {
|
|
list_del_init(&ced->list);
|
|
return 0;
|
|
}
|
|
|
|
return ced == per_cpu(tick_cpu_device, cpu).evtdev ? -EAGAIN : -EBUSY;
|
|
}
|
|
|
|
/*
|
|
* SMP function call to unbind a device
|
|
*/
|
|
static void __clockevents_unbind(void *arg)
|
|
{
|
|
struct ce_unbind *cu = arg;
|
|
int res;
|
|
|
|
raw_spin_lock(&clockevents_lock);
|
|
res = __clockevents_try_unbind(cu->ce, smp_processor_id());
|
|
if (res == -EAGAIN)
|
|
res = clockevents_replace(cu->ce);
|
|
cu->res = res;
|
|
raw_spin_unlock(&clockevents_lock);
|
|
}
|
|
|
|
/*
|
|
* Issues smp function call to unbind a per cpu device. Called with
|
|
* clockevents_mutex held.
|
|
*/
|
|
static int clockevents_unbind(struct clock_event_device *ced, int cpu)
|
|
{
|
|
struct ce_unbind cu = { .ce = ced, .res = -ENODEV };
|
|
|
|
smp_call_function_single(cpu, __clockevents_unbind, &cu, 1);
|
|
return cu.res;
|
|
}
|
|
|
|
/*
|
|
* Unbind a clockevents device.
|
|
*/
|
|
int clockevents_unbind_device(struct clock_event_device *ced, int cpu)
|
|
{
|
|
int ret;
|
|
|
|
mutex_lock(&clockevents_mutex);
|
|
ret = clockevents_unbind(ced, cpu);
|
|
mutex_unlock(&clockevents_mutex);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(clockevents_unbind);
|
|
|
|
/**
|
|
* clockevents_register_device - register a clock event device
|
|
* @dev: device to register
|
|
*/
|
|
void clockevents_register_device(struct clock_event_device *dev)
|
|
{
|
|
unsigned long flags;
|
|
|
|
BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);
|
|
if (!dev->cpumask) {
|
|
WARN_ON(num_possible_cpus() > 1);
|
|
dev->cpumask = cpumask_of(smp_processor_id());
|
|
}
|
|
|
|
raw_spin_lock_irqsave(&clockevents_lock, flags);
|
|
|
|
list_add(&dev->list, &clockevent_devices);
|
|
tick_check_new_device(dev);
|
|
clockevents_notify_released();
|
|
|
|
raw_spin_unlock_irqrestore(&clockevents_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(clockevents_register_device);
|
|
|
|
void clockevents_config(struct clock_event_device *dev, u32 freq)
|
|
{
|
|
u64 sec;
|
|
|
|
if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
|
|
return;
|
|
|
|
/*
|
|
* Calculate the maximum number of seconds we can sleep. Limit
|
|
* to 10 minutes for hardware which can program more than
|
|
* 32bit ticks so we still get reasonable conversion values.
|
|
*/
|
|
sec = dev->max_delta_ticks;
|
|
do_div(sec, freq);
|
|
if (!sec)
|
|
sec = 1;
|
|
else if (sec > 600 && dev->max_delta_ticks > UINT_MAX)
|
|
sec = 600;
|
|
|
|
clockevents_calc_mult_shift(dev, freq, sec);
|
|
dev->min_delta_ns = cev_delta2ns(dev->min_delta_ticks, dev, false);
|
|
dev->max_delta_ns = cev_delta2ns(dev->max_delta_ticks, dev, true);
|
|
}
|
|
|
|
/**
|
|
* clockevents_config_and_register - Configure and register a clock event device
|
|
* @dev: device to register
|
|
* @freq: The clock frequency
|
|
* @min_delta: The minimum clock ticks to program in oneshot mode
|
|
* @max_delta: The maximum clock ticks to program in oneshot mode
|
|
*
|
|
* min/max_delta can be 0 for devices which do not support oneshot mode.
|
|
*/
|
|
void clockevents_config_and_register(struct clock_event_device *dev,
|
|
u32 freq, unsigned long min_delta,
|
|
unsigned long max_delta)
|
|
{
|
|
dev->min_delta_ticks = min_delta;
|
|
dev->max_delta_ticks = max_delta;
|
|
clockevents_config(dev, freq);
|
|
clockevents_register_device(dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(clockevents_config_and_register);
|
|
|
|
int __clockevents_update_freq(struct clock_event_device *dev, u32 freq)
|
|
{
|
|
clockevents_config(dev, freq);
|
|
|
|
if (dev->mode == CLOCK_EVT_MODE_ONESHOT)
|
|
return clockevents_program_event(dev, dev->next_event, false);
|
|
|
|
if (dev->mode == CLOCK_EVT_MODE_PERIODIC)
|
|
dev->set_mode(CLOCK_EVT_MODE_PERIODIC, dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* clockevents_update_freq - Update frequency and reprogram a clock event device.
|
|
* @dev: device to modify
|
|
* @freq: new device frequency
|
|
*
|
|
* Reconfigure and reprogram a clock event device in oneshot
|
|
* mode. Must be called on the cpu for which the device delivers per
|
|
* cpu timer events. If called for the broadcast device the core takes
|
|
* care of serialization.
|
|
*
|
|
* Returns 0 on success, -ETIME when the event is in the past.
|
|
*/
|
|
int clockevents_update_freq(struct clock_event_device *dev, u32 freq)
|
|
{
|
|
unsigned long flags;
|
|
int ret;
|
|
|
|
local_irq_save(flags);
|
|
ret = tick_broadcast_update_freq(dev, freq);
|
|
if (ret == -ENODEV)
|
|
ret = __clockevents_update_freq(dev, freq);
|
|
local_irq_restore(flags);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Noop handler when we shut down an event device
|
|
*/
|
|
void clockevents_handle_noop(struct clock_event_device *dev)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* clockevents_exchange_device - release and request clock devices
|
|
* @old: device to release (can be NULL)
|
|
* @new: device to request (can be NULL)
|
|
*
|
|
* Called from the notifier chain. clockevents_lock is held already
|
|
*/
|
|
void clockevents_exchange_device(struct clock_event_device *old,
|
|
struct clock_event_device *new)
|
|
{
|
|
unsigned long flags;
|
|
|
|
local_irq_save(flags);
|
|
/*
|
|
* Caller releases a clock event device. We queue it into the
|
|
* released list and do a notify add later.
|
|
*/
|
|
if (old) {
|
|
module_put(old->owner);
|
|
clockevents_set_mode(old, CLOCK_EVT_MODE_UNUSED);
|
|
list_del(&old->list);
|
|
list_add(&old->list, &clockevents_released);
|
|
}
|
|
|
|
if (new) {
|
|
BUG_ON(new->mode != CLOCK_EVT_MODE_UNUSED);
|
|
clockevents_shutdown(new);
|
|
}
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
/**
|
|
* clockevents_suspend - suspend clock devices
|
|
*/
|
|
void clockevents_suspend(void)
|
|
{
|
|
struct clock_event_device *dev;
|
|
|
|
list_for_each_entry_reverse(dev, &clockevent_devices, list)
|
|
if (dev->suspend)
|
|
dev->suspend(dev);
|
|
}
|
|
|
|
/**
|
|
* clockevents_resume - resume clock devices
|
|
*/
|
|
void clockevents_resume(void)
|
|
{
|
|
struct clock_event_device *dev;
|
|
|
|
list_for_each_entry(dev, &clockevent_devices, list)
|
|
if (dev->resume)
|
|
dev->resume(dev);
|
|
}
|
|
|
|
#ifdef CONFIG_GENERIC_CLOCKEVENTS
|
|
/**
|
|
* clockevents_notify - notification about relevant events
|
|
* Returns 0 on success, any other value on error
|
|
*/
|
|
int clockevents_notify(unsigned long reason, void *arg)
|
|
{
|
|
struct clock_event_device *dev, *tmp;
|
|
unsigned long flags;
|
|
int cpu, ret = 0;
|
|
|
|
raw_spin_lock_irqsave(&clockevents_lock, flags);
|
|
|
|
switch (reason) {
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_ON:
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
|
|
tick_broadcast_on_off(reason, arg);
|
|
break;
|
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:
|
|
ret = tick_broadcast_oneshot_control(reason);
|
|
break;
|
|
|
|
case CLOCK_EVT_NOTIFY_CPU_DYING:
|
|
tick_handover_do_timer(arg);
|
|
break;
|
|
|
|
case CLOCK_EVT_NOTIFY_SUSPEND:
|
|
tick_suspend();
|
|
tick_suspend_broadcast();
|
|
break;
|
|
|
|
case CLOCK_EVT_NOTIFY_RESUME:
|
|
tick_resume();
|
|
break;
|
|
|
|
case CLOCK_EVT_NOTIFY_CPU_DEAD:
|
|
tick_shutdown_broadcast_oneshot(arg);
|
|
tick_shutdown_broadcast(arg);
|
|
tick_shutdown(arg);
|
|
/*
|
|
* Unregister the clock event devices which were
|
|
* released from the users in the notify chain.
|
|
*/
|
|
list_for_each_entry_safe(dev, tmp, &clockevents_released, list)
|
|
list_del(&dev->list);
|
|
/*
|
|
* Now check whether the CPU has left unused per cpu devices
|
|
*/
|
|
cpu = *((int *)arg);
|
|
list_for_each_entry_safe(dev, tmp, &clockevent_devices, list) {
|
|
if (cpumask_test_cpu(cpu, dev->cpumask) &&
|
|
cpumask_weight(dev->cpumask) == 1 &&
|
|
!tick_is_broadcast_device(dev)) {
|
|
BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);
|
|
list_del(&dev->list);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
raw_spin_unlock_irqrestore(&clockevents_lock, flags);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(clockevents_notify);
|
|
|
|
#ifdef CONFIG_SYSFS
|
|
struct bus_type clockevents_subsys = {
|
|
.name = "clockevents",
|
|
.dev_name = "clockevent",
|
|
};
|
|
|
|
static DEFINE_PER_CPU(struct device, tick_percpu_dev);
|
|
static struct tick_device *tick_get_tick_dev(struct device *dev);
|
|
|
|
static ssize_t sysfs_show_current_tick_dev(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct tick_device *td;
|
|
ssize_t count = 0;
|
|
|
|
raw_spin_lock_irq(&clockevents_lock);
|
|
td = tick_get_tick_dev(dev);
|
|
if (td && td->evtdev)
|
|
count = snprintf(buf, PAGE_SIZE, "%s\n", td->evtdev->name);
|
|
raw_spin_unlock_irq(&clockevents_lock);
|
|
return count;
|
|
}
|
|
static DEVICE_ATTR(current_device, 0444, sysfs_show_current_tick_dev, NULL);
|
|
|
|
/* We don't support the abomination of removable broadcast devices */
|
|
static ssize_t sysfs_unbind_tick_dev(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
char name[CS_NAME_LEN];
|
|
ssize_t ret = sysfs_get_uname(buf, name, count);
|
|
struct clock_event_device *ce;
|
|
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = -ENODEV;
|
|
mutex_lock(&clockevents_mutex);
|
|
raw_spin_lock_irq(&clockevents_lock);
|
|
list_for_each_entry(ce, &clockevent_devices, list) {
|
|
if (!strcmp(ce->name, name)) {
|
|
ret = __clockevents_try_unbind(ce, dev->id);
|
|
break;
|
|
}
|
|
}
|
|
raw_spin_unlock_irq(&clockevents_lock);
|
|
/*
|
|
* We hold clockevents_mutex, so ce can't go away
|
|
*/
|
|
if (ret == -EAGAIN)
|
|
ret = clockevents_unbind(ce, dev->id);
|
|
mutex_unlock(&clockevents_mutex);
|
|
return ret ? ret : count;
|
|
}
|
|
static DEVICE_ATTR(unbind_device, 0200, NULL, sysfs_unbind_tick_dev);
|
|
|
|
#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
|
|
static struct device tick_bc_dev = {
|
|
.init_name = "broadcast",
|
|
.id = 0,
|
|
.bus = &clockevents_subsys,
|
|
};
|
|
|
|
static struct tick_device *tick_get_tick_dev(struct device *dev)
|
|
{
|
|
return dev == &tick_bc_dev ? tick_get_broadcast_device() :
|
|
&per_cpu(tick_cpu_device, dev->id);
|
|
}
|
|
|
|
static __init int tick_broadcast_init_sysfs(void)
|
|
{
|
|
int err = device_register(&tick_bc_dev);
|
|
|
|
if (!err)
|
|
err = device_create_file(&tick_bc_dev, &dev_attr_current_device);
|
|
return err;
|
|
}
|
|
#else
|
|
static struct tick_device *tick_get_tick_dev(struct device *dev)
|
|
{
|
|
return &per_cpu(tick_cpu_device, dev->id);
|
|
}
|
|
static inline int tick_broadcast_init_sysfs(void) { return 0; }
|
|
#endif
|
|
|
|
static int __init tick_init_sysfs(void)
|
|
{
|
|
int cpu;
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
struct device *dev = &per_cpu(tick_percpu_dev, cpu);
|
|
int err;
|
|
|
|
dev->id = cpu;
|
|
dev->bus = &clockevents_subsys;
|
|
err = device_register(dev);
|
|
if (!err)
|
|
err = device_create_file(dev, &dev_attr_current_device);
|
|
if (!err)
|
|
err = device_create_file(dev, &dev_attr_unbind_device);
|
|
if (err)
|
|
return err;
|
|
}
|
|
return tick_broadcast_init_sysfs();
|
|
}
|
|
|
|
static int __init clockevents_init_sysfs(void)
|
|
{
|
|
int err = subsys_system_register(&clockevents_subsys, NULL);
|
|
|
|
if (!err)
|
|
err = tick_init_sysfs();
|
|
return err;
|
|
}
|
|
device_initcall(clockevents_init_sysfs);
|
|
#endif /* SYSFS */
|
|
|
|
#endif /* GENERIC_CLOCK_EVENTS */
|