Skip to content

Commit

Permalink
clockevents: Manage device's state separately for the core
Browse files Browse the repository at this point in the history 
'enum clock_event_mode' is used for two purposes today:

 - to pass mode to the driver of clockevent device::set_mode().

 - for managing state of the device for clockevents core.

For supporting new modes/states we have moved away from the
legacy set_mode() callback to new per-mode/state callbacks. New
modes/states shouldn't be exposed to the legacy (now OBSOLOTE)
callbacks and so we shouldn't add new states to 'enum
clock_event_mode'.

Lets have separate enums for the two use cases mentioned above.
Keep using the earlier enum for legacy set_mode() callback and
mark it OBSOLETE. And add another enum to clearly specify the
possible states of a clockevent device.

This also renames the newly added per-mode callbacks to reflect
state changes.

We haven't got rid of 'mode' member of 'struct
clock_event_device' as it is used by some of the clockevent
drivers and it would automatically die down once we migrate
those drivers to the new interface. It ('mode') is only updated
now for the drivers using the legacy interface.

Suggested-by: Peter Zijlstra <peterz@infradead.org>
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Daniel Lezcano <daniel.lezcano@linaro.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Kevin Hilman <khilman@linaro.org>
Cc: Preeti U Murthy <preeti@linux.vnet.ibm.com>
Cc: linaro-kernel@lists.linaro.org
Cc: linaro-networking@linaro.org
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/b6b0143a8a57bd58352ad35e08c25424c879c0cb.1425037853.git.viresh.kumar@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
  • Loading branch information
@vireshk
vireshk authored and Ingo Molnar committed Mar 27, 2015
1 parent 554ef38 commit 77e32c8
Show file tree
Hide file tree
Showing 7 changed files with 111 additions and 85 deletions.
8 changes: 4 additions & 4 deletions arch/arm/common/bL_switcher.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -152,7 +152,7 @@ static int bL_switch_to(unsigned int new_cluster_id)
unsigned int ob_mpidr, ob_cpu, ob_cluster, ib_mpidr, ib_cpu, ib_cluster;
struct completion inbound_alive;
struct tick_device *tdev;
enum clock_event_mode tdev_mode;
enum clock_event_state tdev_state;
long volatile *handshake_ptr;
int ipi_nr, ret;

Expand Down Expand Up @@ -223,8 +223,8 @@ static int bL_switch_to(unsigned int new_cluster_id)
if (tdev && !cpumask_equal(tdev->evtdev->cpumask, cpumask_of(this_cpu)))
tdev = NULL;
if (tdev) {
tdev_mode = tdev->evtdev->mode;
clockevents_set_mode(tdev->evtdev, CLOCK_EVT_MODE_SHUTDOWN);
tdev_state = tdev->evtdev->state;
clockevents_set_state(tdev->evtdev, CLOCK_EVT_STATE_SHUTDOWN);
}

ret = cpu_pm_enter();
Expand Down Expand Up @@ -252,7 +252,7 @@ static int bL_switch_to(unsigned int new_cluster_id)
ret = cpu_pm_exit();

if (tdev) {
clockevents_set_mode(tdev->evtdev, tdev_mode);
clockevents_set_state(tdev->evtdev, tdev_state);
clockevents_program_event(tdev->evtdev,
tdev->evtdev->next_event, 1);
}
Expand Down
44 changes: 31 additions & 13 deletions include/linux/clockchips.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,15 +32,31 @@ enum clock_event_nofitiers {
struct clock_event_device;
struct module;

/* Clock event mode commands */
/* Clock event mode commands for legacy ->set_mode(): OBSOLETE */
enum clock_event_mode {
CLOCK_EVT_MODE_UNUSED = 0,
CLOCK_EVT_MODE_SHUTDOWN,
CLOCK_EVT_MODE_PERIODIC,
CLOCK_EVT_MODE_ONESHOT,
CLOCK_EVT_MODE_RESUME,
};

/* Legacy ->set_mode() callback doesn't support below modes */
/*
* Possible states of a clock event device.
*
* DETACHED: Device is not used by clockevents core. Initial state or can be
* reached from SHUTDOWN.
* SHUTDOWN: Device is powered-off. Can be reached from PERIODIC or ONESHOT.
* PERIODIC: Device is programmed to generate events periodically. Can be
* reached from DETACHED or SHUTDOWN.
* ONESHOT: Device is programmed to generate event only once. Can be reached
* from DETACHED or SHUTDOWN.
*/
enum clock_event_state {
CLOCK_EVT_STATE_DETACHED = 0,
CLOCK_EVT_STATE_SHUTDOWN,
CLOCK_EVT_STATE_PERIODIC,
CLOCK_EVT_STATE_ONESHOT,
};

/*
Expand Down Expand Up @@ -80,13 +96,14 @@ enum clock_event_mode {
* @min_delta_ns: minimum delta value in ns
* @mult: nanosecond to cycles multiplier
* @shift: nanoseconds to cycles divisor (power of two)
* @mode: operating mode assigned by the management code
* @mode: operating mode, relevant only to ->set_mode(), OBSOLETE
* @state: current state of the device, assigned by the core code
* @features: features
* @retries: number of forced programming retries
* @set_mode: legacy set mode function, only for modes <= CLOCK_EVT_MODE_RESUME.
* @set_mode_periodic: switch mode to periodic, if !set_mode
* @set_mode_oneshot: switch mode to oneshot, if !set_mode
* @set_mode_shutdown: switch mode to shutdown, if !set_mode
* @set_state_periodic: switch state to periodic, if !set_mode
* @set_state_oneshot: switch state to oneshot, if !set_mode
* @set_state_shutdown: switch state to shutdown, if !set_mode
* @tick_resume: resume clkevt device, if !set_mode
* @broadcast: function to broadcast events
* @min_delta_ticks: minimum delta value in ticks stored for reconfiguration
Expand All @@ -111,20 +128,21 @@ struct clock_event_device {
u32 mult;
u32 shift;
enum clock_event_mode mode;
enum clock_event_state state;
unsigned int features;
unsigned long retries;

/*
* Mode transition callback(s): Only one of the two groups should be
* State transition callback(s): Only one of the two groups should be
* defined:
* - set_mode(), only for modes <= CLOCK_EVT_MODE_RESUME.
* - set_mode_{shutdown|periodic|oneshot|resume}().
* - set_state_{shutdown|periodic|oneshot}(), tick_resume().
*/
void (*set_mode)(enum clock_event_mode mode,
struct clock_event_device *);
int (*set_mode_periodic)(struct clock_event_device *);
int (*set_mode_oneshot)(struct clock_event_device *);
int (*set_mode_shutdown)(struct clock_event_device *);
int (*set_state_periodic)(struct clock_event_device *);
int (*set_state_oneshot)(struct clock_event_device *);
int (*set_state_shutdown)(struct clock_event_device *);
int (*tick_resume)(struct clock_event_device *);

void (*broadcast)(const struct cpumask *mask);
Expand Down Expand Up @@ -177,8 +195,8 @@ extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);

extern void clockevents_exchange_device(struct clock_event_device *old,
struct clock_event_device *new);
extern void clockevents_set_mode(struct clock_event_device *dev,
enum clock_event_mode mode);
extern void clockevents_set_state(struct clock_event_device *dev,
enum clock_event_state state);
extern int clockevents_program_event(struct clock_event_device *dev,
ktime_t expires, bool force);

Expand Down
99 changes: 53 additions & 46 deletions kernel/time/clockevents.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -94,71 +94,76 @@ u64 clockevent_delta2ns(unsigned long latch, struct clock_event_device *evt)
}
EXPORT_SYMBOL_GPL(clockevent_delta2ns);

static int __clockevents_set_mode(struct clock_event_device *dev,
enum clock_event_mode mode)
static int __clockevents_set_state(struct clock_event_device *dev,
enum clock_event_state state)
{
/* Transition with legacy set_mode() callback */
if (dev->set_mode) {
/* Legacy callback doesn't support new modes */
if (mode > CLOCK_EVT_MODE_ONESHOT)
if (state > CLOCK_EVT_STATE_ONESHOT)
return -ENOSYS;
dev->set_mode(mode, dev);
/*
* 'clock_event_state' and 'clock_event_mode' have 1-to-1
* mapping until *_ONESHOT, and so a simple cast will work.
*/
dev->set_mode((enum clock_event_mode)state, dev);
dev->mode = (enum clock_event_mode)state;
return 0;
}

if (dev->features & CLOCK_EVT_FEAT_DUMMY)
return 0;

/* Transition with new mode-specific callbacks */
switch (mode) {
case CLOCK_EVT_MODE_UNUSED:
/* Transition with new state-specific callbacks */
switch (state) {
case CLOCK_EVT_STATE_DETACHED:
/*
* This is an internal state, which is guaranteed to go from
* SHUTDOWN to UNUSED. No driver interaction required.
* SHUTDOWN to DETACHED. No driver interaction required.
*/
return 0;

case CLOCK_EVT_MODE_SHUTDOWN:
return dev->set_mode_shutdown(dev);
case CLOCK_EVT_STATE_SHUTDOWN:
return dev->set_state_shutdown(dev);

case CLOCK_EVT_MODE_PERIODIC:
case CLOCK_EVT_STATE_PERIODIC:
/* Core internal bug */
if (!(dev->features & CLOCK_EVT_FEAT_PERIODIC))
return -ENOSYS;
return dev->set_mode_periodic(dev);
return dev->set_state_periodic(dev);

case CLOCK_EVT_MODE_ONESHOT:
case CLOCK_EVT_STATE_ONESHOT:
/* Core internal bug */
if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))
return -ENOSYS;
return dev->set_mode_oneshot(dev);
return dev->set_state_oneshot(dev);

default:
return -ENOSYS;
}
}

/**
* clockevents_set_mode - set the operating mode of a clock event device
* clockevents_set_state - set the operating state of a clock event device
* @dev: device to modify
* @mode: new mode
* @state: new state
*
* Must be called with interrupts disabled !
*/
void clockevents_set_mode(struct clock_event_device *dev,
enum clock_event_mode mode)
void clockevents_set_state(struct clock_event_device *dev,
enum clock_event_state state)
{
if (dev->mode != mode) {
if (__clockevents_set_mode(dev, mode))
if (dev->state != state) {
if (__clockevents_set_state(dev, state))
return;

dev->mode = mode;
dev->state = state;

/*
* 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 (state == CLOCK_EVT_STATE_ONESHOT) {
if (unlikely(!dev->mult)) {
dev->mult = 1;
WARN_ON(1);
Expand All @@ -173,7 +178,7 @@ void clockevents_set_mode(struct clock_event_device *dev,
*/
void clockevents_shutdown(struct clock_event_device *dev)
{
clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
clockevents_set_state(dev, CLOCK_EVT_STATE_SHUTDOWN);
dev->next_event.tv64 = KTIME_MAX;
}

Expand All @@ -185,13 +190,12 @@ int clockevents_tick_resume(struct clock_event_device *dev)
{
int ret = 0;

if (dev->set_mode)
if (dev->set_mode) {
dev->set_mode(CLOCK_EVT_MODE_RESUME, dev);
else if (dev->tick_resume)
ret = dev->tick_resume(dev);

if (likely(!ret))
dev->mode = CLOCK_EVT_MODE_RESUME;
} else if (dev->tick_resume) {
ret = dev->tick_resume(dev);
}

return ret;
}
Expand Down Expand Up @@ -248,7 +252,7 @@ static int clockevents_program_min_delta(struct clock_event_device *dev)
delta = dev->min_delta_ns;
dev->next_event = ktime_add_ns(ktime_get(), delta);

if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
if (dev->state == CLOCK_EVT_STATE_SHUTDOWN)
return 0;

dev->retries++;
Expand Down Expand Up @@ -285,7 +289,7 @@ static int clockevents_program_min_delta(struct clock_event_device *dev)
delta = dev->min_delta_ns;
dev->next_event = ktime_add_ns(ktime_get(), delta);

if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
if (dev->state == CLOCK_EVT_STATE_SHUTDOWN)
return 0;

dev->retries++;
Expand Down Expand Up @@ -317,7 +321,7 @@ int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,

dev->next_event = expires;

if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
if (dev->state == CLOCK_EVT_STATE_SHUTDOWN)
return 0;

/* Shortcut for clockevent devices that can deal with ktime. */
Expand Down Expand Up @@ -362,7 +366,7 @@ 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)
if (dev == ced || dev->state != CLOCK_EVT_STATE_DETACHED)
continue;

if (!tick_check_replacement(newdev, dev))
Expand All @@ -388,7 +392,7 @@ static int clockevents_replace(struct clock_event_device *ced)
static int __clockevents_try_unbind(struct clock_event_device *ced, int cpu)
{
/* Fast track. Device is unused */
if (ced->mode == CLOCK_EVT_MODE_UNUSED) {
if (ced->state == CLOCK_EVT_STATE_DETACHED) {
list_del_init(&ced->list);
return 0;
}
Expand Down Expand Up @@ -438,30 +442,30 @@ int clockevents_unbind_device(struct clock_event_device *ced, int cpu)
}
EXPORT_SYMBOL_GPL(clockevents_unbind);

/* Sanity check of mode transition callbacks */
/* Sanity check of state transition callbacks */
static int clockevents_sanity_check(struct clock_event_device *dev)
{
/* Legacy set_mode() callback */
if (dev->set_mode) {
/* We shouldn't be supporting new modes now */
WARN_ON(dev->set_mode_periodic || dev->set_mode_oneshot ||
dev->set_mode_shutdown || dev->tick_resume);
WARN_ON(dev->set_state_periodic || dev->set_state_oneshot ||
dev->set_state_shutdown || dev->tick_resume);
return 0;
}

if (dev->features & CLOCK_EVT_FEAT_DUMMY)
return 0;

/* New mode-specific callbacks */
if (!dev->set_mode_shutdown)
/* New state-specific callbacks */
if (!dev->set_state_shutdown)
return -EINVAL;

if ((dev->features & CLOCK_EVT_FEAT_PERIODIC) &&
!dev->set_mode_periodic)
!dev->set_state_periodic)
return -EINVAL;

if ((dev->features & CLOCK_EVT_FEAT_ONESHOT) &&
!dev->set_mode_oneshot)
!dev->set_state_oneshot)
return -EINVAL;

return 0;
Expand All @@ -478,6 +482,9 @@ void clockevents_register_device(struct clock_event_device *dev)
BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);
BUG_ON(clockevents_sanity_check(dev));

/* Initialize state to DETACHED */
dev->state = CLOCK_EVT_STATE_DETACHED;

if (!dev->cpumask) {
WARN_ON(num_possible_cpus() > 1);
dev->cpumask = cpumask_of(smp_processor_id());
Expand Down Expand Up @@ -541,11 +548,11 @@ int __clockevents_update_freq(struct clock_event_device *dev, u32 freq)
{
clockevents_config(dev, freq);

if (dev->mode == CLOCK_EVT_MODE_ONESHOT)
if (dev->state == CLOCK_EVT_STATE_ONESHOT)
return clockevents_program_event(dev, dev->next_event, false);

if (dev->mode == CLOCK_EVT_MODE_PERIODIC)
return __clockevents_set_mode(dev, CLOCK_EVT_MODE_PERIODIC);
if (dev->state == CLOCK_EVT_STATE_PERIODIC)
return __clockevents_set_state(dev, CLOCK_EVT_STATE_PERIODIC);

return 0;
}
Expand Down Expand Up @@ -601,13 +608,13 @@ void clockevents_exchange_device(struct clock_event_device *old,
*/
if (old) {
module_put(old->owner);
clockevents_set_mode(old, CLOCK_EVT_MODE_UNUSED);
clockevents_set_state(old, CLOCK_EVT_STATE_DETACHED);
list_del(&old->list);
list_add(&old->list, &clockevents_released);
}

if (new) {
BUG_ON(new->mode != CLOCK_EVT_MODE_UNUSED);
BUG_ON(new->state != CLOCK_EVT_STATE_DETACHED);
clockevents_shutdown(new);
}
local_irq_restore(flags);
Expand Down Expand Up @@ -693,7 +700,7 @@ int clockevents_notify(unsigned long reason, void *arg)
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);
BUG_ON(dev->state != CLOCK_EVT_STATE_DETACHED);
list_del(&dev->list);
}
}
Expand Down
Loading

0 comments on commit 77e32c8

Please sign in to comment.