mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Arjan van de Ven](/assets/img/avatar_default.png)
Add infrastructure to track "maximum allowable latency" for power saving policies. The reason for adding this infrastructure is that power management in the idle loop needs to make a tradeoff between latency and power savings (deeper power save modes have a longer latency to running code again). The code that today makes this tradeoff just does a rather simple algorithm; however this is not good enough: There are devices and use cases where a lower latency is required than that the higher power saving states provide. An example would be audio playback, but another example is the ipw2100 wireless driver that right now has a very direct and ugly acpi hook to disable some higher power states randomly when it gets certain types of error. The proposed solution is to have an interface where drivers can * announce the maximum latency (in microseconds) that they can deal with * modify this latency * give up their constraint and a function where the code that decides on power saving strategy can query the current global desired maximum. This patch has a user of each side: on the consumer side, ACPI is patched to use this, on the producer side the ipw2100 driver is patched. A generic maximum latency is also registered of 2 timer ticks (more and you lose accurate time tracking after all). While the existing users of the patch are x86 specific, the infrastructure is not. I'd like to ask the arch maintainers of other architectures if the infrastructure is generic enough for their use (assuming the architecture has such a tradeoff as concept at all), and the sound/multimedia driver owners to look at the driver facing API to see if this is something they can use. [akpm@osdl.org: cleanups] Signed-off-by: Arjan van de Ven <arjan@linux.intel.com> Signed-off-by: Ingo Molnar <mingo@elte.hu> Acked-by: Jesse Barnes <jesse.barnes@intel.com> Cc: "Brown, Len" <len.brown@intel.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
279 lines
8.4 KiB
C
279 lines
8.4 KiB
C
/*
|
|
* latency.c: Explicit system-wide latency-expectation infrastructure
|
|
*
|
|
* The purpose of this infrastructure is to allow device drivers to set
|
|
* latency constraint they have and to collect and summarize these
|
|
* expectations globally. The cummulated result can then be used by
|
|
* power management and similar users to make decisions that have
|
|
* tradoffs with a latency component.
|
|
*
|
|
* An example user of this are the x86 C-states; each higher C state saves
|
|
* more power, but has a higher exit latency. For the idle loop power
|
|
* code to make a good decision which C-state to use, information about
|
|
* acceptable latencies is required.
|
|
*
|
|
* An example announcer of latency is an audio driver that knowns it
|
|
* will get an interrupt when the hardware has 200 usec of samples
|
|
* left in the DMA buffer; in that case the driver can set a latency
|
|
* constraint of, say, 150 usec.
|
|
*
|
|
* Multiple drivers can each announce their maximum accepted latency,
|
|
* to keep these appart, a string based identifier is used.
|
|
*
|
|
*
|
|
* (C) Copyright 2006 Intel Corporation
|
|
* Author: Arjan van de Ven <arjan@linux.intel.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; version 2
|
|
* of the License.
|
|
*/
|
|
|
|
#include <linux/latency.h>
|
|
#include <linux/list.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
#include <linux/notifier.h>
|
|
#include <asm/atomic.h>
|
|
|
|
struct latency_info {
|
|
struct list_head list;
|
|
int usecs;
|
|
char *identifier;
|
|
};
|
|
|
|
/*
|
|
* locking rule: all modifications to current_max_latency and
|
|
* latency_list need to be done while holding the latency_lock.
|
|
* latency_lock needs to be taken _irqsave.
|
|
*/
|
|
static atomic_t current_max_latency;
|
|
static DEFINE_SPINLOCK(latency_lock);
|
|
|
|
static LIST_HEAD(latency_list);
|
|
static BLOCKING_NOTIFIER_HEAD(latency_notifier);
|
|
|
|
/*
|
|
* This function returns the maximum latency allowed, which
|
|
* happens to be the minimum of all maximum latencies on the
|
|
* list.
|
|
*/
|
|
static int __find_max_latency(void)
|
|
{
|
|
int min = INFINITE_LATENCY;
|
|
struct latency_info *info;
|
|
|
|
list_for_each_entry(info, &latency_list, list) {
|
|
if (info->usecs < min)
|
|
min = info->usecs;
|
|
}
|
|
return min;
|
|
}
|
|
|
|
/**
|
|
* set_acceptable_latency - sets the maximum latency acceptable
|
|
* @identifier: string that identifies this driver
|
|
* @usecs: maximum acceptable latency for this driver
|
|
*
|
|
* This function informs the kernel that this device(driver)
|
|
* can accept at most usecs latency. This setting is used for
|
|
* power management and similar tradeoffs.
|
|
*
|
|
* This function sleeps and can only be called from process
|
|
* context.
|
|
* Calling this function with an existing identifier is valid
|
|
* and will cause the existing latency setting to be changed.
|
|
*/
|
|
void set_acceptable_latency(char *identifier, int usecs)
|
|
{
|
|
struct latency_info *info, *iter;
|
|
unsigned long flags;
|
|
int found_old = 0;
|
|
|
|
info = kzalloc(sizeof(struct latency_info), GFP_KERNEL);
|
|
if (!info)
|
|
return;
|
|
info->usecs = usecs;
|
|
info->identifier = kstrdup(identifier, GFP_KERNEL);
|
|
if (!info->identifier)
|
|
goto free_info;
|
|
|
|
spin_lock_irqsave(&latency_lock, flags);
|
|
list_for_each_entry(iter, &latency_list, list) {
|
|
if (strcmp(iter->identifier, identifier)==0) {
|
|
found_old = 1;
|
|
iter->usecs = usecs;
|
|
break;
|
|
}
|
|
}
|
|
if (!found_old)
|
|
list_add(&info->list, &latency_list);
|
|
|
|
if (usecs < atomic_read(¤t_max_latency))
|
|
atomic_set(¤t_max_latency, usecs);
|
|
|
|
spin_unlock_irqrestore(&latency_lock, flags);
|
|
|
|
blocking_notifier_call_chain(&latency_notifier,
|
|
atomic_read(¤t_max_latency), NULL);
|
|
|
|
/*
|
|
* if we inserted the new one, we're done; otherwise there was
|
|
* an existing one so we need to free the redundant data
|
|
*/
|
|
if (!found_old)
|
|
return;
|
|
|
|
kfree(info->identifier);
|
|
free_info:
|
|
kfree(info);
|
|
}
|
|
EXPORT_SYMBOL_GPL(set_acceptable_latency);
|
|
|
|
/**
|
|
* modify_acceptable_latency - changes the maximum latency acceptable
|
|
* @identifier: string that identifies this driver
|
|
* @usecs: maximum acceptable latency for this driver
|
|
*
|
|
* This function informs the kernel that this device(driver)
|
|
* can accept at most usecs latency. This setting is used for
|
|
* power management and similar tradeoffs.
|
|
*
|
|
* This function does not sleep and can be called in any context.
|
|
* Trying to use a non-existing identifier silently gets ignored.
|
|
*
|
|
* Due to the atomic nature of this function, the modified latency
|
|
* value will only be used for future decisions; past decisions
|
|
* can still lead to longer latencies in the near future.
|
|
*/
|
|
void modify_acceptable_latency(char *identifier, int usecs)
|
|
{
|
|
struct latency_info *iter;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&latency_lock, flags);
|
|
list_for_each_entry(iter, &latency_list, list) {
|
|
if (strcmp(iter->identifier, identifier) == 0) {
|
|
iter->usecs = usecs;
|
|
break;
|
|
}
|
|
}
|
|
if (usecs < atomic_read(¤t_max_latency))
|
|
atomic_set(¤t_max_latency, usecs);
|
|
spin_unlock_irqrestore(&latency_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(modify_acceptable_latency);
|
|
|
|
/**
|
|
* remove_acceptable_latency - removes the maximum latency acceptable
|
|
* @identifier: string that identifies this driver
|
|
*
|
|
* This function removes a previously set maximum latency setting
|
|
* for the driver and frees up any resources associated with the
|
|
* bookkeeping needed for this.
|
|
*
|
|
* This function does not sleep and can be called in any context.
|
|
* Trying to use a non-existing identifier silently gets ignored.
|
|
*/
|
|
void remove_acceptable_latency(char *identifier)
|
|
{
|
|
unsigned long flags;
|
|
int newmax = 0;
|
|
struct latency_info *iter, *temp;
|
|
|
|
spin_lock_irqsave(&latency_lock, flags);
|
|
|
|
list_for_each_entry_safe(iter, temp, &latency_list, list) {
|
|
if (strcmp(iter->identifier, identifier) == 0) {
|
|
list_del(&iter->list);
|
|
newmax = iter->usecs;
|
|
kfree(iter->identifier);
|
|
kfree(iter);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* If we just deleted the system wide value, we need to
|
|
* recalculate with a full search
|
|
*/
|
|
if (newmax == atomic_read(¤t_max_latency)) {
|
|
newmax = __find_max_latency();
|
|
atomic_set(¤t_max_latency, newmax);
|
|
}
|
|
spin_unlock_irqrestore(&latency_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(remove_acceptable_latency);
|
|
|
|
/**
|
|
* system_latency_constraint - queries the system wide latency maximum
|
|
*
|
|
* This function returns the system wide maximum latency in
|
|
* microseconds.
|
|
*
|
|
* This function does not sleep and can be called in any context.
|
|
*/
|
|
int system_latency_constraint(void)
|
|
{
|
|
return atomic_read(¤t_max_latency);
|
|
}
|
|
EXPORT_SYMBOL_GPL(system_latency_constraint);
|
|
|
|
/**
|
|
* synchronize_acceptable_latency - recalculates all latency decisions
|
|
*
|
|
* This function will cause a callback to various kernel pieces that
|
|
* will make those pieces rethink their latency decisions. This implies
|
|
* that if there are overlong latencies in hardware state already, those
|
|
* latencies get taken right now. When this call completes no overlong
|
|
* latency decisions should be active anymore.
|
|
*
|
|
* Typical usecase of this is after a modify_acceptable_latency() call,
|
|
* which in itself is non-blocking and non-synchronizing.
|
|
*
|
|
* This function blocks and should not be called with locks held.
|
|
*/
|
|
|
|
void synchronize_acceptable_latency(void)
|
|
{
|
|
blocking_notifier_call_chain(&latency_notifier,
|
|
atomic_read(¤t_max_latency), NULL);
|
|
}
|
|
EXPORT_SYMBOL_GPL(synchronize_acceptable_latency);
|
|
|
|
/*
|
|
* Latency notifier: this notifier gets called when a non-atomic new
|
|
* latency value gets set. The expectation nof the caller of the
|
|
* non-atomic set is that when the call returns, future latencies
|
|
* are within bounds, so the functions on the notifier list are
|
|
* expected to take the overlong latencies immediately, inside the
|
|
* callback, and not make a overlong latency decision anymore.
|
|
*
|
|
* The callback gets called when the new latency value is made
|
|
* active so system_latency_constraint() returns the new latency.
|
|
*/
|
|
int register_latency_notifier(struct notifier_block * nb)
|
|
{
|
|
return blocking_notifier_chain_register(&latency_notifier, nb);
|
|
}
|
|
EXPORT_SYMBOL_GPL(register_latency_notifier);
|
|
|
|
int unregister_latency_notifier(struct notifier_block * nb)
|
|
{
|
|
return blocking_notifier_chain_unregister(&latency_notifier, nb);
|
|
}
|
|
EXPORT_SYMBOL_GPL(unregister_latency_notifier);
|
|
|
|
static __init int latency_init(void)
|
|
{
|
|
atomic_set(¤t_max_latency, INFINITE_LATENCY);
|
|
/*
|
|
* we don't want by default to have longer latencies than 2 ticks,
|
|
* since that would cause lost ticks
|
|
*/
|
|
set_acceptable_latency("kernel", 2*1000000/HZ);
|
|
return 0;
|
|
}
|
|
|
|
module_init(latency_init);
|