|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [RFC PATCH v3 8/8] xen/arm: cpufreq: add xen-cpufreq driver
Xen changes frequencies on CPUs using this high-level
cpufreq driver.
Signed-off-by: Oleksandr Dmytryshyn <oleksandr.dmytryshyn@xxxxxxxxxxxxxxx>
---
drivers/cpufreq/Kconfig | 19 +
drivers/cpufreq/Makefile | 1 +
drivers/cpufreq/cpufreq_drv_ops.c | 13 +-
drivers/cpufreq/cpufreq_drv_ops.h | 4 +
drivers/cpufreq/xen-cpufreq.c | 889 ++++++++++++++++++++++++++++++++++++++
include/xen/interface/platform.h | 1 +
include/xen/interface/xen.h | 1 +
7 files changed, 926 insertions(+), 2 deletions(-)
create mode 100644 drivers/cpufreq/xen-cpufreq.c
diff --git a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig
index f5a8f84..5fd439e 100644
--- a/drivers/cpufreq/Kconfig
+++ b/drivers/cpufreq/Kconfig
@@ -19,6 +19,25 @@ config CPU_FREQ
If in doubt, say N.
+config XEN_CPUFREQ
+ bool "Xen Cpufreq driver"
+ depends on XEN_DOM0
+ default n
+ select CPUFREQ_DRV_OPS
+ help
+ This driver uploads Power Management information to the Xen
+ hypervisor and changes CPUs frequency using CPU Frequency scaling
+ drivers.
+
+ To do that the driver uses CPU Frequency scaling drivers to parse
+ the Power Management data and uploads said information to the Xen
+ hypervisor. Then the Xen hypervisor can select the proper Pxx states.
+
+ Then the Xen hypervisor can change CPUs frequency by giving commands
+ via this driver to the CPU Frequency scaling driver.
+
+ If in doubt, say N.
+
if CPUFREQ_DRV_OPS
config CPU_FREQ_TABLE
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index f12a0d3..c8d5037 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -1,5 +1,6 @@
# CPUfreq core
obj-$(CONFIG_CPU_FREQ) += cpufreq.o
+obj-$(CONFIG_XEN_CPUFREQ) += xen-cpufreq.o
obj-$(CONFIG_CPUFREQ_DRV_OPS) += cpufreq_drv_ops.o
# CPUfreq stats
obj-$(CONFIG_CPU_FREQ_STAT) += cpufreq_stats.o
diff --git a/drivers/cpufreq/cpufreq_drv_ops.c
b/drivers/cpufreq/cpufreq_drv_ops.c
index c971442..71c3357 100644
--- a/drivers/cpufreq/cpufreq_drv_ops.c
+++ b/drivers/cpufreq/cpufreq_drv_ops.c
@@ -18,6 +18,8 @@
#include <linux/init.h>
#include <linux/export.h>
+#include <xen/xen.h>
+
static struct cpufreq_drv_ops *ops;
struct kobject *get_cpufreq_global_kobject(void)
@@ -177,10 +179,17 @@ EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
static int __init cpufreq_drv_ops_init(void)
{
+ if (xen_initial_domain()) {
+#ifdef CONFIG_XEN_CPUFREQ
+ ops = &xen_cpufreq_drv_ops;
+ pr_debug("using xen_cpufreq_drv_ops\n");
+#endif
+ } else {
#ifdef CONFIG_CPU_FREQ
- ops = &kern_cpufreq_drv_ops;
- pr_debug("using kern_cpufreq_drv_ops\n");
+ ops = &kern_cpufreq_drv_ops;
+ pr_debug("using kern_cpufreq_drv_ops\n");
#endif
+ }
return 0;
}
diff --git a/drivers/cpufreq/cpufreq_drv_ops.h
b/drivers/cpufreq/cpufreq_drv_ops.h
index 5cc8e05..d02d509 100644
--- a/drivers/cpufreq/cpufreq_drv_ops.h
+++ b/drivers/cpufreq/cpufreq_drv_ops.h
@@ -47,4 +47,8 @@ struct cpufreq_drv_ops {
extern struct cpufreq_drv_ops kern_cpufreq_drv_ops;
#endif
+#ifdef CONFIG_XEN_CPUFREQ
+extern struct cpufreq_drv_ops xen_cpufreq_drv_ops;
+#endif
+
#endif /* _CPUFREQ_DRV_OPS_H */
diff --git a/drivers/cpufreq/xen-cpufreq.c b/drivers/cpufreq/xen-cpufreq.c
new file mode 100644
index 0000000..a7f0977
--- /dev/null
+++ b/drivers/cpufreq/xen-cpufreq.c
@@ -0,0 +1,889 @@
+/*
+ * Copyright (C) 2001 Russell King
+ * (C) 2002 - 2003 Dominik Brodowski <linux@xxxxxxxx>
+ *
+ * Oct 2005 - Ashok Raj <ashok.raj@xxxxxxxxx>
+ * Added handling for CPU hotplug
+ * Feb 2006 - Jacob Shin <jacob.shin@xxxxxxx>
+ * Fix handling for CPU hotplug -- affected CPUs
+ *
+ * (C) 2014 GlobalLogic Inc.
+ *
+ * Based on drivers/cpufreq/cpufreq.c
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/notifier.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/irq.h>
+#include <linux/workqueue.h>
+#include <linux/cpufreq.h>
+
+#include <trace/events/power.h>
+
+#include <xen/xen.h>
+#include <xen/events.h>
+#include <xen/interface/xen.h>
+#include <xen/interface/platform.h>
+#include <xen/interface/sysctl.h>
+#include <asm/xen/hypercall.h>
+
+#include "cpufreq_drv_ops.h"
+
+#ifdef CONFIG_CPUMASK_OFFSTACK
+#error CONFIG_CPUMASK_OFFSTACK config should not be used with this driver
+#endif
+
+static int xen_nr_cpus;
+static int xen_irq;
+
+#define for_each_xen_cpu(cpu, mask) \
+ for ((cpu) = -1; \
+ (cpu) = cpumask_next((cpu), (mask)), \
+ (cpu) < xen_nr_cpus;)
+
+static struct cpufreq_driver *cpufreq_driver;
+static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
+
+static DEFINE_SPINLOCK(cpufreq_driver_lock);
+
+/*
+ * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
+ * all cpufreq/hotplug/workqueue/etc related lock issues.
+ *
+ * The rules for this semaphore:
+ * - Any routine that wants to read from the policy structure will
+ * do a down_read on this semaphore.
+ * - Any routine that will write to the policy structure and/or may take away
+ * the policy altogether (eg. CPU hotplug), will hold this lock in write
+ * mode before doing so.
+ *
+ * Additional rules:
+ * - Governor routines that can be called in cpufreq hotplug path should not
+ * take this sem as top level hotplug notifier handler takes this.
+ * - Lock should not be held across
+ * __cpufreq_governor(data, CPUFREQ_GOV_STOP);
+ */
+static DEFINE_PER_CPU(int, cpufreq_policy_cpu);
+static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
+
+#define lock_policy_rwsem(mode, cpu) \
+static int lock_policy_rwsem_##mode \
+(int cpu) \
+{ \
+ int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu); \
+ BUG_ON(policy_cpu == -1); \
+ down_##mode(&per_cpu(cpu_policy_rwsem, policy_cpu)); \
+ \
+ return 0; \
+}
+
+lock_policy_rwsem(write, cpu);
+
+static void unlock_policy_rwsem_write(int cpu)
+{
+ int policy_cpu = per_cpu(cpufreq_policy_cpu, cpu);
+ BUG_ON(policy_cpu == -1);
+ up_write(&per_cpu(cpu_policy_rwsem, policy_cpu));
+}
+
+/**
+ * The "transition" notifier list for kernel code that needs to handle
+ * changes to devices when the CPU clock speed changes.
+ * The mutex locks this list.
+ */
+static struct srcu_notifier_head xen_cpufreq_transition_notifier_list;
+
+static bool init_cpufreq_transition_notifier_list_called;
+static int __init init_cpufreq_transition_notifier_list(void)
+{
+ srcu_init_notifier_head(&xen_cpufreq_transition_notifier_list);
+ init_cpufreq_transition_notifier_list_called = true;
+ return 0;
+}
+pure_initcall(init_cpufreq_transition_notifier_list);
+
+static struct cpufreq_policy *xen_cpufreq_cpu_get(unsigned int cpu)
+{
+ struct cpufreq_policy *data = NULL;
+ unsigned long flags;
+
+ if (cpu >= xen_nr_cpus)
+ goto err_out;
+
+ /* get the cpufreq driver */
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+
+ if (!cpufreq_driver)
+ goto err_out_unlock;
+
+ /* get the CPU */
+ data = per_cpu(cpufreq_cpu_data, cpu);
+
+err_out_unlock:
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+err_out:
+ return data;
+}
+
+static void xen_cpufreq_cpu_put(struct cpufreq_policy *data)
+{
+ module_put(cpufreq_driver->owner);
+}
+
+static int push_data_to_hypervisor(struct cpufreq_policy *policy,
+ struct cpufreq_frequency_table *table)
+{
+ int ret = 0;
+ unsigned int i;
+ unsigned int cpu;
+ uint32_t platform_limit = 0;
+ unsigned int max_freq = 0;
+ unsigned int state_count = 0;
+ unsigned int prev_freq = 0;
+ struct xen_processor_px *dst_states;
+ struct xen_processor_performance *dst_perf;
+ struct xen_platform_op op = {
+ .cmd = XENPF_set_processor_pminfo,
+ .interface_version = XENPF_INTERFACE_VERSION,
+ .u.set_pminfo.type = XEN_PM_PX,
+ };
+
+ dst_perf = &op.u.set_pminfo.perf;
+
+ /* Check freq table and find max frequency */
+ for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+ unsigned int freq = table[i].frequency;
+ if (freq == CPUFREQ_ENTRY_INVALID)
+ continue;
+
+ if (table[i].index != state_count || freq <= prev_freq) {
+ pr_err("Frequency table format error\n");
+ return -EINVAL;
+ }
+
+ prev_freq = freq;
+ state_count++;
+ if (freq > max_freq)
+ max_freq = freq;
+ }
+
+ if (!state_count)
+ return -EINVAL;
+
+ dst_perf->state_count = state_count;
+
+ dst_states = kcalloc(state_count,
+ sizeof(struct xen_processor_px), GFP_KERNEL);
+
+ if (!dst_states)
+ return -ENOMEM;
+
+ set_xen_guest_handle(dst_perf->states, dst_states);
+
+ /*
+ * Freq table should start from lower values
+ * dst_states should start from higer values
+ */
+ for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
+ unsigned int freq = table[i].frequency;
+ unsigned int tbl_index = state_count - 1 - table[i].index;
+ if (freq == CPUFREQ_ENTRY_INVALID)
+ continue;
+
+ if (freq == max_freq)
+ platform_limit = tbl_index;
+
+ dst_states[tbl_index].core_frequency = freq / 1000;
+ dst_states[tbl_index].transition_latency =
+ policy->cpuinfo.transition_latency / 1000;
+ }
+
+ dst_perf->shared_type = policy->shared_type;
+ dst_perf->platform_limit = platform_limit;
+ dst_perf->domain_info.domain = policy->cpu;
+ dst_perf->domain_info.num_processors = xen_nr_cpus;
+ dst_perf->flags = XEN_PX_DATA;
+
+ for_each_xen_cpu(cpu, policy->cpus) {
+ op.u.set_pminfo.id = cpu;
+ ret = HYPERVISOR_dom0_op(&op);
+ if (ret) {
+ pr_debug("Hypervisor error(%d) for CPU%u\n", ret, cpu);
+ goto err_free_states;
+ }
+ pr_debug("CPU%u - P-states uploaded\n", cpu);
+
+ for (i = 0; i < dst_perf->state_count; i++) {
+ pr_debug(" state %d: %d MHz, %d uS\n",
+ i, (u32) dst_states[i].core_frequency,
+ (u32) dst_states[i].transition_latency);
+ }
+ }
+
+err_free_states:
+ kfree(dst_states);
+ return ret;
+}
+
+/*
+ * Returns:
+ * Negative: Failure
+ * 0: Success
+ * Positive: When we have a managed CPU and the sysfs got symlinked
+ */
+static int xen_cpufreq_add_dev_policy(unsigned int cpu,
+ struct cpufreq_policy *policy)
+{
+ int ret = 0;
+#ifdef CONFIG_SMP
+ unsigned long flags;
+ unsigned int j;
+
+ for_each_cpu(j, policy->cpus) {
+ struct cpufreq_policy *managed_policy;
+
+ if (cpu == j)
+ continue;
+
+ /* Check for existing affected CPUs.
+ * They may not be aware of it due to CPU Hotplug.
+ * cpufreq_cpu_put is called when the device is removed
+ * in __cpufreq_remove_dev()
+ */
+ managed_policy = xen_cpufreq_cpu_get(j);
+ if (unlikely(managed_policy)) {
+ /* Set proper policy_cpu */
+ unlock_policy_rwsem_write(cpu);
+ per_cpu(cpufreq_policy_cpu, cpu) =
+ managed_policy->cpu;
+
+ if (lock_policy_rwsem_write(cpu) < 0) {
+ /* Should not go through policy unlock path */
+ if (cpufreq_driver->exit)
+ cpufreq_driver->exit(policy);
+ xen_cpufreq_cpu_put(managed_policy);
+ return -EBUSY;
+ }
+
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+ cpumask_copy(managed_policy->cpus, policy->cpus);
+ per_cpu(cpufreq_cpu_data, cpu) = managed_policy;
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+ pr_debug("CPU already managed, adding link\n");
+
+ /*
+ * Success. We only needed to be added to the mask.
+ * Call driver->exit() because only the cpu parent of
+ * the kobj needed to call init().
+ */
+ if (cpufreq_driver->exit)
+ cpufreq_driver->exit(policy);
+
+ return 1;
+ }
+ }
+#endif
+ return ret;
+}
+
+/**
+ * xen_cpufreq_add_dev - add a CPU device
+ *
+ * Adds the cpufreq interface for a CPU device.
+ */
+static int xen_cpufreq_add_dev(unsigned int cpu)
+{
+ int ret = 0;
+ struct cpufreq_policy *policy;
+ unsigned long flags;
+ unsigned int j;
+
+ pr_debug("adding CPU %u\n", cpu);
+
+#ifdef CONFIG_SMP
+ /* check whether a different CPU already registered this
+ * CPU because it is in the same boat. */
+ policy = xen_cpufreq_cpu_get(cpu);
+ if (unlikely(policy)) {
+ xen_cpufreq_cpu_put(policy);
+ return 0;
+ }
+#endif
+
+ if (!try_module_get(cpufreq_driver->owner)) {
+ ret = -EINVAL;
+ goto module_out;
+ }
+
+ ret = -ENOMEM;
+ policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
+ if (!policy)
+ goto nomem_out;
+
+ if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
+ goto err_free_policy;
+
+ if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
+ goto err_free_cpumask;
+
+ policy->cpu = cpu;
+ cpumask_copy(policy->cpus, cpumask_of(cpu));
+
+ /* Initially set CPU itself as the policy_cpu */
+ per_cpu(cpufreq_policy_cpu, cpu) = cpu;
+ ret = (lock_policy_rwsem_write(cpu) < 0);
+ WARN_ON(ret);
+
+ /* call driver. From then on the cpufreq must be able
+ * to accept all calls to ->verify and ->setpolicy for this CPU
+ */
+ ret = cpufreq_driver->init(policy);
+ if (ret) {
+ pr_debug("initialization failed\n");
+ goto err_unlock_policy;
+ }
+ ret = xen_cpufreq_add_dev_policy(cpu, policy);
+ if (ret) {
+ if (ret > 0)
+ /* This is a managed cpu, symlink created,
+ exit with 0 */
+ ret = 0;
+ goto err_unlock_policy;
+ }
+
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+ for_each_cpu(j, policy->cpus) {
+ per_cpu(cpufreq_cpu_data, j) = policy;
+ per_cpu(cpufreq_policy_cpu, j) = policy->cpu;
+ }
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+ unlock_policy_rwsem_write(cpu);
+
+ module_put(cpufreq_driver->owner);
+ pr_debug("initialization complete\n");
+
+ return 0;
+
+err_unlock_policy:
+ unlock_policy_rwsem_write(cpu);
+ free_cpumask_var(policy->related_cpus);
+err_free_cpumask:
+ free_cpumask_var(policy->cpus);
+err_free_policy:
+ kfree(policy);
+nomem_out:
+ module_put(cpufreq_driver->owner);
+module_out:
+ return ret;
+}
+
+/**
+ * __cpufreq_remove_dev - remove a CPU device
+ *
+ * Removes the cpufreq interface for a CPU device.
+ * Caller should already have policy_rwsem in write mode for this CPU.
+ * This routine frees the rwsem before returning.
+ */
+static int __cpufreq_remove_dev(unsigned int cpu)
+{
+ unsigned long flags;
+ struct cpufreq_policy *data;
+#ifdef CONFIG_SMP
+ unsigned int j;
+#endif
+
+ pr_debug("unregistering CPU %u\n", cpu);
+
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+ data = per_cpu(cpufreq_cpu_data, cpu);
+
+ if (!data) {
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+ unlock_policy_rwsem_write(cpu);
+ return -EINVAL;
+ }
+ per_cpu(cpufreq_cpu_data, cpu) = NULL;
+
+
+#ifdef CONFIG_SMP
+ /* if this isn't the CPU which is the parent of the kobj, we
+ * only need to unlink, put and exit
+ */
+ if (unlikely(cpu != data->cpu)) {
+ pr_debug("removing link\n");
+ cpumask_clear_cpu(cpu, data->cpus);
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+ xen_cpufreq_cpu_put(data);
+ unlock_policy_rwsem_write(cpu);
+ return 0;
+ }
+#endif
+
+#ifdef CONFIG_SMP
+
+ /* if we have other CPUs still registered, we need to unlink them,
+ * or else wait_for_completion below will lock up. Clean the
+ * per_cpu(cpufreq_cpu_data) while holding the lock, and remove
+ * the sysfs links afterwards.
+ */
+ if (unlikely(cpumask_weight(data->cpus) > 1)) {
+ for_each_cpu(j, data->cpus) {
+ if (j == cpu)
+ continue;
+ per_cpu(cpufreq_cpu_data, j) = NULL;
+ }
+ }
+
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+ if (unlikely(cpumask_weight(data->cpus) > 1)) {
+ for_each_cpu(j, data->cpus) {
+ if (j == cpu)
+ continue;
+ pr_debug("removing link for cpu %u\n", j);
+ unlock_policy_rwsem_write(cpu);
+ lock_policy_rwsem_write(cpu);
+ xen_cpufreq_cpu_put(data);
+ }
+ }
+#else
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+#endif
+
+ unlock_policy_rwsem_write(cpu);
+
+ lock_policy_rwsem_write(cpu);
+ if (cpufreq_driver->exit)
+ cpufreq_driver->exit(data);
+ unlock_policy_rwsem_write(cpu);
+
+ free_cpumask_var(data->related_cpus);
+ free_cpumask_var(data->cpus);
+ kfree(data);
+
+ return 0;
+}
+
+static int cpufreq_remove_dev(unsigned int cpu)
+{
+ int retval;
+
+ if (unlikely(lock_policy_rwsem_write(cpu)))
+ BUG();
+
+ retval = __cpufreq_remove_dev(cpu);
+ return retval;
+}
+
+/*********************************************************************
+ * EXTERNALLY AFFECTING FREQUENCY CHANGES *
+ *********************************************************************/
+
+/**
+ * adjust_jiffies - adjust the system "loops_per_jiffy"
+ *
+ * This function alters the system "loops_per_jiffy" for the clock
+ * speed change. Note that loops_per_jiffy cannot be updated on SMP
+ * systems as each CPU might be scaled differently. So, use the arch
+ * per-CPU loops_per_jiffy value wherever possible.
+ */
+#ifndef CONFIG_SMP
+static unsigned long l_p_j_ref;
+static unsigned int l_p_j_ref_freq;
+
+static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
+{
+ if (ci->flags & CPUFREQ_CONST_LOOPS)
+ return;
+
+ if (!l_p_j_ref_freq) {
+ l_p_j_ref = loops_per_jiffy;
+ l_p_j_ref_freq = ci->old;
+ pr_debug("saving %lu as reference value for loops_per_jiffy; "
+ "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
+ }
+ if ((val == CPUFREQ_POSTCHANGE && ci->old != ci->new) ||
+ (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
+ loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
+ ci->new);
+ pr_debug("scaling loops_per_jiffy to %lu "
+ "for frequency %u kHz\n", loops_per_jiffy, ci->new);
+ }
+}
+#else
+static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
+{
+ return;
+}
+#endif
+
+
+/**
+ * xen_cpufreq_notify_transition - call notifier chain and adjust_jiffies
+ * on frequency transition.
+ *
+ * This function calls the transition notifiers and the "adjust_jiffies"
+ * function. It is called twice on all CPU frequency changes that have
+ * external effects.
+ */
+void xen_cpufreq_notify_transition(struct cpufreq_freqs *freqs,
+ unsigned int state)
+{
+ struct cpufreq_policy *policy;
+
+ BUG_ON(irqs_disabled());
+
+ freqs->flags = cpufreq_driver->flags;
+ pr_debug("notification %u of frequency transition to %u kHz\n",
+ state, freqs->new);
+
+ policy = per_cpu(cpufreq_cpu_data, freqs->cpu);
+ switch (state) {
+ case CPUFREQ_PRECHANGE:
+ /* detect if the driver reported a value as "old frequency"
+ * which is not equal to what the cpufreq core thinks is
+ * "old frequency".
+ */
+ if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
+ if ((policy) && (policy->cpu == freqs->cpu) &&
+ (policy->cur) && (policy->cur != freqs->old)) {
+ pr_debug("Warning: CPU frequency is"
+ " %u, cpufreq assumed %u kHz.\n",
+ freqs->old, policy->cur);
+ freqs->old = policy->cur;
+ }
+ }
+ srcu_notifier_call_chain(&xen_cpufreq_transition_notifier_list,
+ CPUFREQ_PRECHANGE, freqs);
+ adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
+ break;
+
+ case CPUFREQ_POSTCHANGE:
+ adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
+ pr_debug("FREQ: %lu - CPU: %lu\n", (unsigned long)freqs->new,
+ (unsigned long)freqs->cpu);
+ trace_power_frequency(POWER_PSTATE, freqs->new, freqs->cpu);
+ trace_cpu_frequency(freqs->new, freqs->cpu);
+ srcu_notifier_call_chain(&xen_cpufreq_transition_notifier_list,
+ CPUFREQ_POSTCHANGE, freqs);
+ if (likely(policy) && likely(policy->cpu == freqs->cpu))
+ policy->cur = freqs->new;
+ break;
+ }
+}
+
+/*********************************************************************
+ * GOVERNORS *
+ *********************************************************************/
+
+int __xen_cpufreq_driver_target(struct cpufreq_policy *policy,
+ unsigned int target_freq,
+ unsigned int relation)
+{
+ int retval = -EINVAL;
+ unsigned int old_target_freq = target_freq;
+
+ /* Make sure that target_freq is within supported range */
+ if (target_freq > policy->max)
+ target_freq = policy->max;
+ if (target_freq < policy->min)
+ target_freq = policy->min;
+
+ pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
+ policy->cpu, target_freq, relation, old_target_freq);
+
+ if (target_freq == policy->cur)
+ return 0;
+
+ if (cpufreq_driver->target)
+ retval = cpufreq_driver->target(policy, target_freq,
+ relation);
+
+ return retval;
+}
+
+int xen_cpufreq_driver_target(struct cpufreq_policy *policy,
+ unsigned int target_freq,
+ unsigned int relation)
+{
+ int ret = -EINVAL;
+
+ if (!policy)
+ goto no_policy;
+
+ if (unlikely(lock_policy_rwsem_write(policy->cpu)))
+ goto fail;
+
+ ret = __xen_cpufreq_driver_target(policy, target_freq, relation);
+
+ unlock_policy_rwsem_write(policy->cpu);
+
+fail:
+ xen_cpufreq_cpu_put(policy);
+no_policy:
+ return ret;
+}
+
+/*********************************************************************
+ * HANDLE COMMANDS FROM XEN *
+ *********************************************************************/
+static void cpufreq_work_hnd(struct work_struct *w);
+
+
+static struct workqueue_struct *cpufreq_wq;
+static DECLARE_WORK(cpufreq_work, cpufreq_work_hnd);
+
+static void cpufreq_work_hnd(struct work_struct *w)
+{
+ int ret;
+ struct cpufreq_policy *policy;
+ struct xen_sysctl op = {
+ .cmd = XEN_SYSCTL_cpufreq_op,
+ .interface_version = XEN_SYSCTL_INTERFACE_VERSION,
+ };
+ struct xen_sysctl_cpufreq_op *cf_op = &op.u.cpufreq_op;
+
+
+ cf_op->cmd = XEN_SYSCTL_CPUFREQ_get_target;
+ ret = HYPERVISOR_sysctl(&op);
+ if (ret) {
+ pr_err("Hypervisor cpufreq error get targer (%d)\n", ret);
+ return;
+ }
+
+ policy = xen_cpufreq_cpu_get(cf_op->u.target.cpu);
+ ret = xen_cpufreq_driver_target(policy,
+ cf_op->u.target.freq,
+ cf_op->u.target.relation);
+
+ cf_op->cmd = XEN_SYSCTL_CPUFREQ_set_result;
+ cf_op->u.result = ret;
+ ret = HYPERVISOR_sysctl(&op);
+ if (ret) {
+ pr_err("Hypervisor cpufreq set result error (%d)\n", ret);
+ return;
+ }
+}
+
+static irqreturn_t cpufreq_interrupt(int irq, void *data)
+{
+ queue_work(cpufreq_wq, &cpufreq_work);
+ return IRQ_HANDLED;
+}
+
+/*********************************************************************
+ * REGISTER / UNREGISTER CPUFREQ DRIVER *
+ *********************************************************************/
+
+/**
+ * xen_cpufreq_register_driver - register a CPU Frequency driver
+ * @driver_data: A struct cpufreq_driver containing the values#
+ * submitted by the CPU Frequency driver.
+ *
+ * Registers a CPU Frequency driver to this core code. This code
+ * returns zero on success, -EBUSY when another driver got here first
+ * (and isn't unregistered in the meantime).
+ *
+ */
+int xen_cpufreq_register_driver(struct cpufreq_driver *driver_data)
+{
+ unsigned long flags;
+ int ret;
+ unsigned int cpu;
+ struct cpufreq_frequency_table *table;
+ struct cpufreq_policy *policy;
+ cpumask_var_t pushed_cpus;
+ int irq;
+
+ if (!xen_nr_cpus)
+ return -EPROBE_DEFER;
+
+ if (!driver_data || !driver_data->verify || !driver_data->init ||
+ (!driver_data->target))
+ return -EINVAL;
+
+ pr_debug("trying to register driver %s\n", driver_data->name);
+
+ if (driver_data->setpolicy)
+ driver_data->flags |= CPUFREQ_CONST_LOOPS;
+
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+
+ if (cpufreq_driver) {
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+ return -EBUSY;
+ }
+ cpufreq_driver = driver_data;
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+ irq = bind_virq_to_irq(VIRQ_CPUFREQ, 0);
+ if (irq < 0) {
+ pr_err("Bind virq (%d) error (%d)\n", VIRQ_CPUFREQ, irq);
+ ret = irq;
+ goto err_remove_drv;
+ }
+
+ irq_clear_status_flags(irq, IRQ_NOREQUEST|IRQ_NOAUTOEN|IRQ_NOPROBE);
+
+ ret = request_irq(irq, cpufreq_interrupt, 0,
+ "xen_cpufreq", NULL);
+
+ if (ret < 0) {
+ pr_err("Request irq (%d) error (%d)\n", irq, ret);
+ goto err_unbind_from_irqhnd;
+ }
+
+ xen_irq = irq;
+
+ for (cpu = 0; cpu < xen_nr_cpus; cpu++) {
+ ret = xen_cpufreq_add_dev(cpu);
+ if (ret)
+ goto err_remove_cpu;
+ }
+
+ if (!zalloc_cpumask_var(&pushed_cpus, GFP_KERNEL))
+ goto err_remove_cpu;
+
+ for (cpu = 0; cpu < xen_nr_cpus; cpu++) {
+ if (cpumask_test_cpu(cpu, pushed_cpus))
+ continue;
+
+ policy = xen_cpufreq_cpu_get(cpu);
+ if (!policy) {
+ ret = -EINVAL;
+ goto err_free_cpumask;
+ }
+
+ cpumask_or(pushed_cpus, pushed_cpus, policy->cpus);
+ table = cpufreq_frequency_get_table(policy->cpu);
+ if (!table) {
+ ret = -EINVAL;
+ goto err_free_cpumask;
+ }
+
+ ret = push_data_to_hypervisor(policy, table);
+ if (ret)
+ goto err_free_cpumask;
+ }
+
+ free_cpumask_var(pushed_cpus);
+
+ pr_debug("driver %s up and running\n", driver_data->name);
+
+ return 0;
+
+err_free_cpumask:
+ free_cpumask_var(pushed_cpus);
+err_remove_cpu:
+ for (cpu = 0; cpu < xen_nr_cpus; cpu++)
+ cpufreq_remove_dev(cpu);
+err_unbind_from_irqhnd:
+ unbind_from_irqhandler(irq, NULL);
+err_remove_drv:
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+ cpufreq_driver = NULL;
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+ return ret;
+}
+
+/**
+ * xen_cpufreq_unregister_driver - unregister the current CPUFreq driver
+ *
+ * Unregister the current CPUFreq driver. Only call this if you have
+ * the right to do so, i.e. if you have succeeded in initialising before!
+ * Returns zero if successful, and -EINVAL if the cpufreq_driver is
+ * currently not initialised.
+ */
+int xen_cpufreq_unregister_driver(struct cpufreq_driver *driver)
+{
+ unsigned long flags;
+ unsigned int cpu;
+
+ if (!cpufreq_driver || (driver != cpufreq_driver))
+ return -EINVAL;
+
+ pr_debug("unregistering driver %s\n", driver->name);
+
+ unbind_from_irqhandler(xen_irq, NULL);
+
+ for (cpu = 0; cpu < xen_nr_cpus; cpu++)
+ cpufreq_remove_dev(cpu);
+
+ spin_lock_irqsave(&cpufreq_driver_lock, flags);
+ cpufreq_driver = NULL;
+ spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
+
+ return 0;
+}
+
+struct cpufreq_drv_ops xen_cpufreq_drv_ops = {
+ .notify_transition = xen_cpufreq_notify_transition,
+ .register_driver = xen_cpufreq_register_driver,
+ .unregister_driver = xen_cpufreq_unregister_driver,
+};
+
+static int __init xen_cpufreq_init(void)
+{
+ int ret;
+ int i;
+
+ struct xen_sysctl op = {
+ .cmd = XEN_SYSCTL_physinfo,
+ .interface_version = XEN_SYSCTL_INTERFACE_VERSION,
+ };
+
+ ret = HYPERVISOR_sysctl(&op);
+ if (ret) {
+ pr_err("Hypervisor get physinfo error (%d)\n", ret);
+ return ret;
+ }
+
+ xen_nr_cpus = op.u.physinfo.nr_cpus;
+ if (xen_nr_cpus == 0 || xen_nr_cpus > NR_CPUS) {
+ xen_nr_cpus = 0;
+ pr_err("Wrong CPUs amount (%d)\n", xen_nr_cpus);
+ return -EINVAL;
+ }
+
+ for (i = 0; i < xen_nr_cpus; i++) {
+ per_cpu(cpufreq_policy_cpu, i) = -1;
+ init_rwsem(&per_cpu(cpu_policy_rwsem, i));
+ }
+
+ cpufreq_wq = alloc_workqueue("xen_cpufreq", 0, 1);
+ if (!cpufreq_wq) {
+ pr_err("Create workqueue error\n");
+ ret = -ENOMEM;
+ goto err_create_wq;
+ }
+
+ return 0;
+
+err_create_wq:
+ xen_nr_cpus = 0;
+ return ret;
+}
+
+MODULE_AUTHOR("Oleksandr Dmytryshyn <oleksandr.dmytryshyn@xxxxxxxxxxxxxxx>");
+MODULE_DESCRIPTION("Xen cpufreq driver which uploads PM data to Xen
hypervisor");
+MODULE_LICENSE("GPL");
+
+core_initcall(xen_cpufreq_init);
diff --git a/include/xen/interface/platform.h b/include/xen/interface/platform.h
index c57d5f6..ee3b154 100644
--- a/include/xen/interface/platform.h
+++ b/include/xen/interface/platform.h
@@ -209,6 +209,7 @@ DEFINE_GUEST_HANDLE_STRUCT(xenpf_getidletime_t);
#define XEN_PX_PSS 2
#define XEN_PX_PPC 4
#define XEN_PX_PSD 8
+#define XEN_PX_DATA 16
struct xen_power_register {
uint32_t space_id;
diff --git a/include/xen/interface/xen.h b/include/xen/interface/xen.h
index cf64566..9133110 100644
--- a/include/xen/interface/xen.h
+++ b/include/xen/interface/xen.h
@@ -81,6 +81,7 @@
#define VIRQ_DOM_EXC 3 /* (DOM0) Exceptional event for some domain. */
#define VIRQ_DEBUGGER 6 /* (DOM0) A domain has paused for debugging. */
#define VIRQ_PCPU_STATE 9 /* (DOM0) PCPU state changed */
+#define VIRQ_CPUFREQ 14 /* (DOM0) Notify cpufreq driver */
/* Architecture-specific VIRQ definitions. */
#define VIRQ_ARCH_0 16
--
1.9.1
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |