lkml.org 
[lkml]   [2019]   [Dec]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
SubjectRe: [PATCH 1/2] platform/x86: Add support for Uncore frequency control
From
Date
On Wed, 2019-12-18 at 18:51 +0200, Andy Shevchenko wrote:
> On Sat, Dec 14, 2019 at 2:15 AM Srinivas Pandruvada
> <srinivas.pandruvada@linux.intel.com> wrote:
> >
> > Some server users set limits on the uncore frequency using MSR
> > 620H, while
> > running latency sensitive workloads. Here uncore frequency controls
> > RING/LLC(last-level cache) clocks.
> >
> > But MSR control is not always possible from the user space, so this
> > driver
> > provides a sysfs interface to set max and min frequency limits.
> > This MSR
> > 620H is a die scoped in multi-die system or package scoped in non
> > multi-die
> > systems.
> >
> > When this driver is loaded, a new directory is created under
> > /sys/devices/system/cpu.
> >
> > For example on a two package Skylake server:
> > $cd /sys/devices/system/cpu/intel_uncore_frequency
> >
> > $ls
> > package_00_die_00 package_01_die_00
> >
> > $ls package_00_die_00
> > max_freq_khz min_freq_khz power_up_max_freq_khz
> > power_up_min_freq_khz
> >
> > $grep . *
> > max_freq_khz:2400000
> > min_freq_khz:1200000
> > power_up_max_freq_khz:2400000
> > power_up_min_freq_khz:1200000
> >
> > Here, power_up_max_freq_khz and power_up_min_freq_khz are read only
> > attributes to show power up values of max and min frequencies
> > respectively.
> > Other attributes are read-write, so that users can modify.
> >
>
> Acked-by: Andy Shevchenko <andy.shevchenko@gmail.com>
> in case it goes thru different (doc?) tree.
I can submit separate patches for the documentation, so that these
patches can be submitted via two different trees.

Thanks,
Srinivas


>
> > Signed-off-by: Srinivas Pandruvada <
> > srinivas.pandruvada@linux.intel.com>
> > ---
> > drivers/platform/x86/Kconfig | 11 +
> > drivers/platform/x86/Makefile | 1 +
> > drivers/platform/x86/intel-uncore-frequency.c | 434
> > ++++++++++++++++++
> > 3 files changed, 446 insertions(+)
> > create mode 100644 drivers/platform/x86/intel-uncore-frequency.c
> >
> > diff --git a/drivers/platform/x86/Kconfig
> > b/drivers/platform/x86/Kconfig
> > index 27d5b40fb717..6013c3b96cfd 100644
> > --- a/drivers/platform/x86/Kconfig
> > +++ b/drivers/platform/x86/Kconfig
> > @@ -1337,6 +1337,17 @@ config PCENGINES_APU2
> > To compile this driver as a module, choose M here: the
> > module
> > will be called pcengines-apuv2.
> >
> > +config INTEL_UNCORE_FREQ_CONTROL
> > + tristate "Intel Uncore frequency control driver"
> > + depends on X86_64
> > + help
> > + This driver allows control of uncore frequency limits on
> > + supported server platforms.
> > + Uncore frequency controls RING/LLC (last-level cache)
> > clocks.
> > +
> > + To compile this driver as a module, choose M here: the
> > module
> > + will be called intel-uncore-frequency.
> > +
> > source "drivers/platform/x86/intel_speed_select_if/Kconfig"
> >
> > config SYSTEM76_ACPI
> > diff --git a/drivers/platform/x86/Makefile
> > b/drivers/platform/x86/Makefile
> > index 42d85a00be4e..3747b1f07cf1 100644
> > --- a/drivers/platform/x86/Makefile
> > +++ b/drivers/platform/x86/Makefile
> > @@ -105,3 +105,4 @@ obj-$(CONFIG_INTEL_ATOMISP2_PM) +=
> > intel_atomisp2_pm.o
> > obj-$(CONFIG_PCENGINES_APU2) += pcengines-apuv2.o
> > obj-$(CONFIG_INTEL_SPEED_SELECT_INTERFACE) +=
> > intel_speed_select_if/
> > obj-$(CONFIG_SYSTEM76_ACPI) += system76_acpi.o
> > +obj-$(CONFIG_INTEL_UNCORE_FREQ_CONTROL) += intel-uncore-
> > frequency.o
> > diff --git a/drivers/platform/x86/intel-uncore-frequency.c
> > b/drivers/platform/x86/intel-uncore-frequency.c
> > new file mode 100644
> > index 000000000000..82ee5a3107cf
> > --- /dev/null
> > +++ b/drivers/platform/x86/intel-uncore-frequency.c
> > @@ -0,0 +1,434 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +/*
> > + * Intel Uncore Frequency Setting
> > + * Copyright (c) 2019, Intel Corporation.
> > + * All rights reserved.
> > + *
> > + * Provide interface to set MSR 620 at a granularity of per die.
> > On CPU online,
> > + * one control CPU is identified per die to read/write limit. This
> > control CPU
> > + * is changed, if the CPU state is changed to offline. When the
> > last CPU is
> > + * offline in a die then remove the sysfs object for that die.
> > + * The majority of actual code is related to sysfs create and
> > read/write
> > + * attributes.
> > + *
> > + * Author: Srinivas Pandruvada <
> > srinivas.pandruvada@linux.intel.com>
> > + */
> > +
> > +#include <linux/cpu.h>
> > +#include <linux/module.h>
> > +#include <linux/slab.h>
> > +#include <linux/suspend.h>
> > +#include <asm/cpu_device_id.h>
> > +#include <asm/intel-family.h>
> > +
> > +#define MSR_UNCORE_RATIO_LIMIT 0x620
> > +#define UNCORE_FREQ_KHZ_MULTIPLIER 100000
> > +
> > +/**
> > + * struct uncore_data - Encapsulate all uncore data
> > + * @stored_uncore_data: Last user changed MSR 620 value,
> > which will be restored
> > + * on system resume.
> > + * @power_up_min_freq_khz: Sampled minimum uncore frequency at
> > driver init
> > + * @power_up_max_freq_khz: Sampled maximum uncore frequency at
> > driver init
> > + * @control_cpu: Designated CPU for a die to read/write
> > + * @valid: Mark the data valid/invalid
> > + *
> > + * This structure is used to encapsulate all data related to
> > uncore sysfs
> > + * settings for a die/package.
> > + */
> > +struct uncore_data {
> > + struct kobject kobj;
> > + u64 stored_uncore_data;
> > + u32 power_up_min_freq_khz;
> > + u32 power_up_max_freq_khz;
> > + int control_cpu;
> > + bool valid;
> > +};
> > +
> > +#define to_uncore_data(a) container_of(a, struct uncore_data,
> > kobj)
> > +
> > +/* Max instances for uncore data, one for each die */
> > +static int uncore_max_entries __read_mostly;
> > +/* Storage for uncore data for all instances */
> > +static struct uncore_data *uncore_instances;
> > +/* Root of the all uncore sysfs kobjs */
> > +struct kobject uncore_root_kobj;
> > +/* Stores the CPU mask of the target CPUs to use during uncore
> > read/write */
> > +static cpumask_t uncore_cpu_mask;
> > +/* CPU online callback register instance */
> > +static enum cpuhp_state uncore_hp_state __read_mostly;
> > +/* Mutex to control all mutual exclusions */
> > +static DEFINE_MUTEX(uncore_lock);
> > +
> > +struct uncore_attr {
> > + struct attribute attr;
> > + ssize_t (*show)(struct kobject *kobj,
> > + struct attribute *attr, char *buf);
> > + ssize_t (*store)(struct kobject *kobj,
> > + struct attribute *attr, const char *c,
> > ssize_t count);
> > +};
> > +
> > +#define define_one_uncore_ro(_name) \
> > +static struct uncore_attr _name = \
> > +__ATTR(_name, 0444, show_##_name, NULL)
> > +
> > +#define define_one_uncore_rw(_name) \
> > +static struct uncore_attr _name = \
> > +__ATTR(_name, 0644, show_##_name, store_##_name)
> > +
> > +#define
> > show_uncore_data(member_name) \
> > + static ssize_t show_##member_name(struct kobject
> > *kobj, \
> > + struct attribute
> > *attr, \
> > + char
> > *buf) \
> > + {
> > \
> > + struct uncore_data *data =
> > to_uncore_data(kobj); \
> > + return scnprintf(buf, PAGE_SIZE,
> > "%u\n", \
> > + data-
> > >member_name); \
> > + }
> > \
> > + define_one_uncore_ro(member_name)
> > +
> > +show_uncore_data(power_up_min_freq_khz);
> > +show_uncore_data(power_up_max_freq_khz);
> > +
> > +/* Common function to read MSR 0x620 and read min/max */
> > +static int uncore_read_ratio(struct uncore_data *data, unsigned
> > int *min,
> > + unsigned int *max)
> > +{
> > + u64 cap;
> > + int ret;
> > +
> > + ret = rdmsrl_on_cpu(data->control_cpu,
> > MSR_UNCORE_RATIO_LIMIT, &cap);
> > + if (ret)
> > + return ret;
> > +
> > + *max = (cap & 0x7F) * UNCORE_FREQ_KHZ_MULTIPLIER;
> > + *min = ((cap & GENMASK(14, 8)) >> 8) *
> > UNCORE_FREQ_KHZ_MULTIPLIER;
> > +
> > + return 0;
> > +}
> > +
> > +/* Common function to set min/max ratios to be used by sysfs
> > callbacks */
> > +static int uncore_write_ratio(struct uncore_data *data, unsigned
> > int input,
> > + int set_max)
> > +{
> > + int ret;
> > + u64 cap;
> > +
> > + mutex_lock(&uncore_lock);
> > +
> > + input /= UNCORE_FREQ_KHZ_MULTIPLIER;
> > + if (!input || input > 0x7F) {
> > + ret = -EINVAL;
> > + goto finish_write;
> > + }
> > +
> > + rdmsrl(MSR_UNCORE_RATIO_LIMIT, cap);
> > + if (set_max) {
> > + cap &= ~0x7F;
> > + cap |= input;
> > + } else {
> > + cap &= ~GENMASK(14, 8);
> > + cap |= (input << 8);
> > + }
> > +
> > + ret = wrmsrl_on_cpu(data->control_cpu,
> > MSR_UNCORE_RATIO_LIMIT, cap);
> > + if (ret)
> > + goto finish_write;
> > +
> > + data->stored_uncore_data = cap;
> > +
> > +finish_write:
> > + mutex_unlock(&uncore_lock);
> > +
> > + return ret;
> > +}
> > +
> > +static ssize_t store_min_max_freq_khz(struct kobject *kobj,
> > + struct attribute *attr,
> > + const char *buf, ssize_t
> > count,
> > + int min_max)
> > +{
> > + struct uncore_data *data = to_uncore_data(kobj);
> > + unsigned int input;
> > +
> > + if (kstrtouint(buf, 10, &input))
> > + return -EINVAL;
> > +
> > + uncore_write_ratio(data, input, min_max);
> > +
> > + return count;
> > +}
> > +
> > +static ssize_t show_min_max_freq_khz(struct kobject *kobj,
> > + struct attribute *attr,
> > + char *buf, int min_max)
> > +{
> > + struct uncore_data *data = to_uncore_data(kobj);
> > + unsigned int min, max;
> > + int ret;
> > +
> > + mutex_lock(&uncore_lock);
> > + ret = uncore_read_ratio(data, &min, &max);
> > + mutex_unlock(&uncore_lock);
> > + if (ret)
> > + return ret;
> > +
> > + if (min_max)
> > + return sprintf(buf, "%u\n", max);
> > +
> > + return sprintf(buf, "%u\n", min);
> > +}
> > +
> > +#define store_uncore_min_max(name,
> > min_max) \
> > + static ssize_t store_##name(struct kobject
> > *kobj, \
> > + struct attribute
> > *attr, \
> > + const char *buf, ssize_t
> > count) \
> > + {
> > \
> > +
> > \
> > + return store_min_max_freq_khz(kobj, attr, buf,
> > count, \
> > + min_max);
> > \
> > + }
> > +
> > +#define show_uncore_min_max(name,
> > min_max) \
> > + static ssize_t show_##name(struct kobject
> > *kobj, \
> > + struct attribute *attr, char
> > *buf) \
> > + {
> > \
> > +
> > \
> > + return show_min_max_freq_khz(kobj, attr, buf,
> > min_max); \
> > + }
> > +
> > +store_uncore_min_max(min_freq_khz, 0);
> > +store_uncore_min_max(max_freq_khz, 1);
> > +
> > +show_uncore_min_max(min_freq_khz, 0);
> > +show_uncore_min_max(max_freq_khz, 1);
> > +
> > +define_one_uncore_rw(min_freq_khz);
> > +define_one_uncore_rw(max_freq_khz);
> > +
> > +static struct attribute *uncore_attrs[] = {
> > + &power_up_min_freq_khz.attr,
> > + &power_up_max_freq_khz.attr,
> > + &max_freq_khz.attr,
> > + &min_freq_khz.attr,
> > + NULL
> > +};
> > +
> > +static struct kobj_type uncore_ktype = {
> > + .sysfs_ops = &kobj_sysfs_ops,
> > + .default_attrs = uncore_attrs,
> > +};
> > +
> > +static struct kobj_type uncore_root_ktype = {
> > + .sysfs_ops = &kobj_sysfs_ops,
> > +};
> > +
> > +/* Caller provides protection */
> > +static struct uncore_data *uncore_get_instance(unsigned int cpu)
> > +{
> > + int id = topology_logical_die_id(cpu);
> > +
> > + if (id >= 0 && id < uncore_max_entries)
> > + return &uncore_instances[id];
> > +
> > + return NULL;
> > +}
> > +
> > +static void uncore_add_die_entry(int cpu)
> > +{
> > + struct uncore_data *data;
> > +
> > + mutex_lock(&uncore_lock);
> > + data = uncore_get_instance(cpu);
> > + if (!data) {
> > + mutex_unlock(&uncore_lock);
> > + return;
> > + }
> > +
> > + if (data->valid) {
> > + /* control cpu changed */
> > + data->control_cpu = cpu;
> > + } else {
> > + char str[64];
> > + int ret;
> > +
> > + memset(data, 0, sizeof(*data));
> > + sprintf(str, "package_%02d_die_%02d",
> > + topology_physical_package_id(cpu),
> > + topology_die_id(cpu));
> > +
> > + uncore_read_ratio(data, &data-
> > >power_up_min_freq_khz,
> > + &data->power_up_max_freq_khz);
> > +
> > + ret = kobject_init_and_add(&data->kobj,
> > &uncore_ktype,
> > + &uncore_root_kobj, str);
> > + if (!ret) {
> > + data->control_cpu = cpu;
> > + data->valid = true;
> > + }
> > + }
> > + mutex_unlock(&uncore_lock);
> > +}
> > +
> > +/* Last CPU in this die is offline, so remove sysfs entries */
> > +static void uncore_remove_die_entry(int cpu)
> > +{
> > + struct uncore_data *data;
> > +
> > + mutex_lock(&uncore_lock);
> > + data = uncore_get_instance(cpu);
> > + if (data) {
> > + kobject_put(&data->kobj);
> > + data->control_cpu = -1;
> > + data->valid = false;
> > + }
> > + mutex_unlock(&uncore_lock);
> > +}
> > +
> > +static int uncore_event_cpu_online(unsigned int cpu)
> > +{
> > + int target;
> > +
> > + /* Check if there is an online cpu in the package for
> > uncore MSR */
> > + target = cpumask_any_and(&uncore_cpu_mask,
> > topology_die_cpumask(cpu));
> > + if (target < nr_cpu_ids)
> > + return 0;
> > +
> > + /* Use this CPU on this die as a control CPU */
> > + cpumask_set_cpu(cpu, &uncore_cpu_mask);
> > + uncore_add_die_entry(cpu);
> > +
> > + return 0;
> > +}
> > +
> > +static int uncore_event_cpu_offline(unsigned int cpu)
> > +{
> > + int target;
> > +
> > + /* Check if existing cpu is used for uncore MSRs */
> > + if (!cpumask_test_and_clear_cpu(cpu, &uncore_cpu_mask))
> > + return 0;
> > +
> > + /* Find a new cpu to set uncore MSR */
> > + target = cpumask_any_but(topology_die_cpumask(cpu), cpu);
> > +
> > + if (target < nr_cpu_ids) {
> > + cpumask_set_cpu(target, &uncore_cpu_mask);
> > + uncore_add_die_entry(target);
> > + } else {
> > + uncore_remove_die_entry(cpu);
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +static int uncore_pm_notify(struct notifier_block *nb, unsigned
> > long mode,
> > + void *_unused)
> > +{
> > + int cpu;
> > +
> > + switch (mode) {
> > + case PM_POST_HIBERNATION:
> > + case PM_POST_RESTORE:
> > + case PM_POST_SUSPEND:
> > + for_each_cpu(cpu, &uncore_cpu_mask) {
> > + struct uncore_data *data;
> > + int ret;
> > +
> > + data = uncore_get_instance(cpu);
> > + if (!data || !data->valid || !data-
> > >stored_uncore_data)
> > + continue;
> > +
> > + ret = wrmsrl_on_cpu(cpu,
> > MSR_UNCORE_RATIO_LIMIT,
> > + data-
> > >stored_uncore_data);
> > + if (ret)
> > + return ret;
> > + }
> > + break;
> > + default:
> > + break;
> > + }
> > + return 0;
> > +}
> > +
> > +static struct notifier_block uncore_pm_nb = {
> > + .notifier_call = uncore_pm_notify,
> > +};
> > +
> > +#define ICPU(model) { X86_VENDOR_INTEL, 6, model,
> > X86_FEATURE_ANY, }
> > +
> > +static const struct x86_cpu_id intel_uncore_cpu_ids[] = {
> > + ICPU(INTEL_FAM6_BROADWELL_G),
> > + ICPU(INTEL_FAM6_BROADWELL_X),
> > + ICPU(INTEL_FAM6_BROADWELL_D),
> > + ICPU(INTEL_FAM6_SKYLAKE_X),
> > + ICPU(INTEL_FAM6_ICELAKE_X),
> > + ICPU(INTEL_FAM6_ICELAKE_D),
> > + {}
> > +};
> > +
> > +static int __init intel_uncore_init(void)
> > +{
> > + const struct x86_cpu_id *id;
> > + int ret;
> > +
> > + id = x86_match_cpu(intel_uncore_cpu_ids);
> > + if (!id)
> > + return -ENODEV;
> > +
> > + uncore_max_entries = topology_max_packages() *
> > + topology_max_die_per_packag
> > e();
> > + uncore_instances = kcalloc(uncore_max_entries,
> > + sizeof(*uncore_instances),
> > GFP_KERNEL);
> > + if (!uncore_instances)
> > + return -ENOMEM;
> > +
> > + ret = kobject_init_and_add(&uncore_root_kobj,
> > &uncore_root_ktype,
> > + &cpu_subsys.dev_root->kobj,
> > + "intel_uncore_frequency");
> > + if (ret)
> > + goto err_free;
> > +
> > + ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
> > + "platform/x86/uncore-freq:online",
> > + uncore_event_cpu_online,
> > + uncore_event_cpu_offline);
> > + if (ret < 0)
> > + goto err_rem_kobj;
> > +
> > + uncore_hp_state = ret;
> > +
> > + ret = register_pm_notifier(&uncore_pm_nb);
> > + if (ret)
> > + goto err_rem_state;
> > +
> > + return 0;
> > +
> > +err_rem_state:
> > + cpuhp_remove_state(uncore_hp_state);
> > +err_rem_kobj:
> > + kobject_put(&uncore_root_kobj);
> > +err_free:
> > + kfree(uncore_instances);
> > +
> > + return ret;
> > +}
> > +module_init(intel_uncore_init)
> > +
> > +static void __exit intel_uncore_exit(void)
> > +{
> > + int i;
> > +
> > + unregister_pm_notifier(&uncore_pm_nb);
> > + cpuhp_remove_state(uncore_hp_state);
> > + for (i = 0; i < uncore_max_entries; ++i) {
> > + if (uncore_instances[i].valid)
> > + kobject_put(&uncore_instances[i].kobj);
> > + }
> > + kobject_put(&uncore_root_kobj);
> > + kfree(uncore_instances);
> > +}
> > +module_exit(intel_uncore_exit)
> > +
> > +MODULE_LICENSE("GPL v2");
> > +MODULE_DESCRIPTION("Intel Uncore Frequency Limits Driver");
> > --
> > 2.17.2
> >
>
>

\
 
 \ /
  Last update: 2019-12-23 16:51    [W:0.064 / U:0.924 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site