Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7af7e28c authored by qctecmdr's avatar qctecmdr Committed by Gerrit - the friendly Code Review server
Browse files

Merge "PM / devfreq: Add cache HW monitor governor"

parents 57aa1662 2094bed7

drivers/devfreq/Kconfig

+18 −0
Original line number Diff line number Diff line
@@ -74,6 +74,15 @@ config DEVFREQ_GOV_PASSIVE 
	  through sysfs entries. The passive governor recommends that

	  devfreq device uses the OPP table to get the frequency/voltage.



config DEVFREQ_GOV_QCOM_CACHE_HWMON

	tristate "HW monitor based governor for cache frequency"

	help

	  HW monitor based governor for cache frequency scaling. This

	  governor sets the cache frequency by using PM counters to monitor the

	  CPU's use of cache. Since this governor uses some of the PM counters

	  it can conflict with existing profiling tools. This governor is

	  unlikely to be useful for other devices.



comment "DEVFREQ Drivers"



config ARM_EXYNOS_BUS_DEVFREQ
@@ -127,6 +136,15 @@ config ARM_RK3399_DMC_DEVFREQ 
          It sets the frequency for the memory controller and reads the usage counts

          from hardware.



config DEVFREQ_SIMPLE_DEV

	tristate "Device driver for simple clock device with no status info"

	select DEVFREQ_GOV_PERFORMANCE

	select DEVFREQ_GOV_POWERSAVE

	select DEVFREQ_GOV_USERSPACE

	help

	  Device driver for simple devices that control their frequency using

	  clock APIs and don't have any form of status reporting.



source "drivers/devfreq/event/Kconfig"



endif # PM_DEVFREQ

drivers/devfreq/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -6,12 +6,14 @@ obj-$(CONFIG_DEVFREQ_GOV_PERFORMANCE) += governor_performance.o 
obj-$(CONFIG_DEVFREQ_GOV_POWERSAVE)	+= governor_powersave.o

obj-$(CONFIG_DEVFREQ_GOV_USERSPACE)	+= governor_userspace.o

obj-$(CONFIG_DEVFREQ_GOV_PASSIVE)	+= governor_passive.o

obj-$(CONFIG_DEVFREQ_GOV_QCOM_CACHE_HWMON)	+= governor_cache_hwmon.o



# DEVFREQ Drivers

obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ)	+= exynos-bus.o

obj-$(CONFIG_ARM_RK3399_DMC_DEVFREQ)	+= rk3399_dmc.o

obj-$(CONFIG_ARM_TEGRA_DEVFREQ)		+= tegra30-devfreq.o

obj-$(CONFIG_ARM_TEGRA20_DEVFREQ)	+= tegra20-devfreq.o

obj-$(CONFIG_DEVFREQ_SIMPLE_DEV)	+= devfreq_simple_dev.o



# DEVFREQ Event Drivers

obj-$(CONFIG_PM_DEVFREQ_EVENT)		+= event/

drivers/devfreq/devfreq_simple_dev.c

0 → 100644
+181 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2014, 2019, The Linux Foundation. All rights reserved.

 */



#define pr_fmt(fmt) "devfreq-simple-dev: " fmt



#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/io.h>

#include <linux/delay.h>

#include <linux/ktime.h>

#include <linux/time.h>

#include <linux/err.h>

#include <linux/errno.h>

#include <linux/mutex.h>

#include <linux/platform_device.h>

#include <linux/interrupt.h>

#include <linux/devfreq.h>

#include <linux/of.h>

#include <linux/clk.h>

#include <trace/events/power.h>



struct dev_data {

	struct clk			*clk;

	struct devfreq			*df;

	struct devfreq_dev_profile	profile;

};



static void find_freq(struct devfreq_dev_profile *p, unsigned long *freq,

			u32 flags)

{

	int i;

	unsigned long atmost, atleast, f;



	atmost = p->freq_table[0];

	atleast = p->freq_table[p->max_state-1];

	for (i = 0; i < p->max_state; i++) {

		f = p->freq_table[i];

		if (f <= *freq)

			atmost = max(f, atmost);

		if (f >= *freq)

			atleast = min(f, atleast);

	}



	if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND)

		*freq = atmost;

	else

		*freq = atleast;

}



static int dev_target(struct device *dev, unsigned long *freq, u32 flags)

{

	struct dev_data *d = dev_get_drvdata(dev);

	unsigned long rfreq;



	find_freq(&d->profile, freq, flags);



	rfreq = clk_round_rate(d->clk, *freq * 1000);

	if (IS_ERR_VALUE(rfreq)) {

		dev_err(dev, "devfreq: Cannot find matching frequency for %lu\n",

			*freq);

		return rfreq;

	}



	return clk_set_rate(d->clk, rfreq);

}



static int dev_get_cur_freq(struct device *dev, unsigned long *freq)

{

	struct dev_data *d = dev_get_drvdata(dev);

	unsigned long f;



	f = clk_get_rate(d->clk);

	if (IS_ERR_VALUE(f))

		return f;

	*freq = f / 1000;

	return 0;

}



#define PROP_TBL "freq-tbl-khz"

static int devfreq_clock_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct dev_data *d;

	struct devfreq_dev_profile *p;

	u32 *data, poll;

	const char *gov_name;

	int ret, len, i, j;

	unsigned long f;



	d = devm_kzalloc(dev, sizeof(*d), GFP_KERNEL);

	if (!d)

		return -ENOMEM;

	platform_set_drvdata(pdev, d);



	d->clk = devm_clk_get(dev, "devfreq_clk");

	if (IS_ERR(d->clk))

		return PTR_ERR(d->clk);



	if (!of_find_property(dev->of_node, PROP_TBL, &len))

		return -EINVAL;



	len /= sizeof(*data);

	data = devm_kzalloc(dev, len * sizeof(*data), GFP_KERNEL);

	if (!data)

		return -ENOMEM;



	p = &d->profile;

	p->freq_table = devm_kzalloc(dev, len * sizeof(*p->freq_table),

				     GFP_KERNEL);

	if (!p->freq_table)

		return -ENOMEM;



	ret = of_property_read_u32_array(dev->of_node, PROP_TBL, data, len);

	if (ret < 0)

		return ret;



	j = 0;

	for (i = 0; i < len; i++) {

		f = clk_round_rate(d->clk, data[i] * 1000);

		if (IS_ERR_VALUE(f))

			dev_warn(dev, "Unable to find dev rate for %d KHz\n",

				 data[i]);

		else

			p->freq_table[j++] = f / 1000;

	}

	p->max_state = j;

	devm_kfree(dev, data);



	if (p->max_state == 0) {

		dev_err(dev, "Error parsing property %s!\n", PROP_TBL);

		return -EINVAL;

	}



	p->target = dev_target;

	p->get_cur_freq = dev_get_cur_freq;

	ret = dev_get_cur_freq(dev, &p->initial_freq);

	if (ret < 0)

		return ret;



	p->polling_ms = 50;

	if (!of_property_read_u32(dev->of_node, "polling-ms", &poll))

		p->polling_ms = poll;



	if (of_property_read_string(dev->of_node, "governor", &gov_name))

		gov_name = "performance";



	d->df = devfreq_add_device(dev, p, gov_name, NULL);

	if (IS_ERR(d->df))

		return PTR_ERR_OR_ZERO(d->df);



	return 0;

}



static int devfreq_clock_remove(struct platform_device *pdev)

{

	struct dev_data *d = platform_get_drvdata(pdev);



	devfreq_remove_device(d->df);



	return 0;

}



static const struct of_device_id devfreq_simple_match_table[] = {

	{ .compatible = "devfreq-simple-dev" },

	{}

};



static struct platform_driver devfreq_clock_driver = {

	.probe = devfreq_clock_probe,

	.remove = devfreq_clock_remove,

	.driver = {

		.name = "devfreq-simple-dev",

		.of_match_table = devfreq_simple_match_table,

	},

};

module_platform_driver(devfreq_clock_driver);

MODULE_DESCRIPTION("Devfreq driver for setting generic device clock frequency");

MODULE_LICENSE("GPL v2");

drivers/devfreq/governor_cache_hwmon.c

0 → 100644
+322 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2014, 2019 The Linux Foundation. All rights reserved.

 */



#define pr_fmt(fmt) "cache-hwmon: " fmt



#include <linux/kernel.h>

#include <linux/sizes.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/io.h>

#include <linux/delay.h>

#include <linux/ktime.h>

#include <linux/time.h>

#include <linux/err.h>

#include <linux/errno.h>

#include <linux/mutex.h>

#include <linux/interrupt.h>

#include <linux/platform_device.h>

#include <linux/of.h>

#include <linux/devfreq.h>

#include "governor.h"

#include "governor_cache_hwmon.h"



#define show_attr(name) \

static ssize_t name##_show(struct device *dev,				\

			struct device_attribute *attr, char *buf)	\

{									\

	return scnprintf(buf, PAGE_SIZE, "%u\n", name);			\

}



#define store_attr(name, _min, _max) \

static ssize_t name##_store(struct device *dev,				\

			struct device_attribute *attr, const char *buf,	\

			size_t count)					\

{									\

	int ret;							\

	unsigned int val;						\

	ret = kstrtoint(buf, 10, &val);					\

	if (ret < 0)							\

		return ret;						\

	val = max(val, _min);						\

	val = min(val, _max);						\

	name = val;							\

	return count;							\

}



static struct cache_hwmon *hw;

static unsigned int cycles_per_low_req;

static unsigned int cycles_per_med_req = 20;

static unsigned int cycles_per_high_req = 35;

static unsigned int min_busy = 100;

static unsigned int max_busy = 100;

static unsigned int tolerance_mrps = 5;

static unsigned int guard_band_mhz = 100;

static unsigned int decay_rate = 90;



#define MIN_MS	10U

#define MAX_MS	500U

static unsigned int sample_ms = 50;

static unsigned long prev_mhz;

static ktime_t prev_ts;



static unsigned long measure_mrps_and_set_irq(struct devfreq *df,

			struct mrps_stats *stat)

{

	ktime_t ts;

	unsigned int us;



	/*

	 * Since we are stopping the counters, we don't want this short work

	 * to be interrupted by other tasks and cause the measurements to be

	 * wrong. Not blocking interrupts to avoid affecting interrupt

	 * latency and since they should be short anyway because they run in

	 * atomic context.

	 */

	preempt_disable();



	ts = ktime_get();

	us = ktime_to_us(ktime_sub(ts, prev_ts));

	if (!us)

		us = 1;



	hw->meas_mrps_and_set_irq(df, tolerance_mrps, us, stat);

	prev_ts = ts;



	preempt_enable();



	pr_debug("stat H=%3lu, M=%3lu, T=%3lu, b=%3u, f=%4lu, us=%d\n",

		 stat->high, stat->med, stat->high + stat->med,

		 stat->busy_percent, df->previous_freq / 1000, us);



	return 0;

}



static void compute_cache_freq(struct mrps_stats *mrps, unsigned long *freq)

{

	unsigned long new_mhz;

	unsigned int busy;



	new_mhz = mrps->high * cycles_per_high_req

		+ mrps->med * cycles_per_med_req

		+ mrps->low * cycles_per_low_req;



	busy = max(min_busy, mrps->busy_percent);

	busy = min(max_busy, busy);



	new_mhz *= 100;

	new_mhz /= busy;



	if (new_mhz < prev_mhz) {

		new_mhz = new_mhz * decay_rate + prev_mhz * (100 - decay_rate);

		new_mhz /= 100;

	}

	prev_mhz = new_mhz;



	new_mhz += guard_band_mhz;

	*freq = new_mhz * 1000;

}



#define TOO_SOON_US	(1 * USEC_PER_MSEC)

static irqreturn_t mon_intr_handler(int irq, void *dev)

{

	struct devfreq *df = dev;

	ktime_t ts;

	unsigned int us;

	int ret;



	if (!hw->is_valid_irq(df))

		return IRQ_NONE;



	pr_debug("Got interrupt\n");

	devfreq_monitor_stop(df);



	/*

	 * Don't recalc cache freq if the interrupt comes right after a

	 * previous cache freq calculation.  This is done for two reasons:

	 *

	 * 1. Sampling the cache request during a very short duration can

	 *    result in a very inaccurate measurement due to very short

	 *    bursts.

	 * 2. This can only happen if the limit was hit very close to the end

	 *    of the previous sample period. Which means the current cache

	 *    request estimate is not very off and doesn't need to be

	 *    readjusted.

	 */

	ts = ktime_get();

	us = ktime_to_us(ktime_sub(ts, prev_ts));

	if (us > TOO_SOON_US) {

		mutex_lock(&df->lock);

		ret = update_devfreq(df);

		if (ret < 0)

			pr_err("Unable to update freq on IRQ! (%d)\n", ret);

		mutex_unlock(&df->lock);

	}



	devfreq_monitor_start(df);



	return IRQ_HANDLED;

}



static int devfreq_cache_hwmon_get_freq(struct devfreq *df,

					unsigned long *freq)

{

	struct mrps_stats stat;



	measure_mrps_and_set_irq(df, &stat);

	compute_cache_freq(&stat, freq);



	return 0;

}



show_attr(cycles_per_low_req);

store_attr(cycles_per_low_req, 1U, 100U);

static DEVICE_ATTR_RW(cycles_per_low_req);

show_attr(cycles_per_med_req);

store_attr(cycles_per_med_req, 1U, 100U);

static DEVICE_ATTR_RW(cycles_per_med_req);

show_attr(cycles_per_high_req);

store_attr(cycles_per_high_req, 1U, 100U);

static DEVICE_ATTR_RW(cycles_per_high_req);

show_attr(min_busy);

store_attr(min_busy, 1U, 100U);

static DEVICE_ATTR_RW(min_busy);

show_attr(max_busy);

store_attr(max_busy, 1U, 100U);

static DEVICE_ATTR_RW(max_busy);

show_attr(tolerance_mrps);

store_attr(tolerance_mrps, 0U, 100U);

static DEVICE_ATTR_RW(tolerance_mrps);

show_attr(guard_band_mhz);

store_attr(guard_band_mhz, 0U, 500U);

static DEVICE_ATTR_RW(guard_band_mhz);

show_attr(decay_rate);

store_attr(decay_rate, 0U, 100U);

static DEVICE_ATTR_RW(decay_rate);



static struct attribute *dev_attr[] = {

	&dev_attr_cycles_per_low_req.attr,

	&dev_attr_cycles_per_med_req.attr,

	&dev_attr_cycles_per_high_req.attr,

	&dev_attr_min_busy.attr,

	&dev_attr_max_busy.attr,

	&dev_attr_tolerance_mrps.attr,

	&dev_attr_guard_band_mhz.attr,

	&dev_attr_decay_rate.attr,

	NULL,

};



static struct attribute_group dev_attr_group = {

	.name = "cache_hwmon",

	.attrs = dev_attr,

};



static int start_monitoring(struct devfreq *df)

{

	int ret;

	struct mrps_stats mrps;



	prev_ts = ktime_get();

	prev_mhz = 0;

	mrps.high = (df->previous_freq / 1000) - guard_band_mhz;

	mrps.high /= cycles_per_high_req;



	ret = hw->start_hwmon(df, &mrps);

	if (ret < 0) {

		pr_err("Unable to start HW monitor! (%d)\n", ret);

		return ret;

	}



	devfreq_monitor_start(df);



	ret = request_threaded_irq(hw->irq, NULL, mon_intr_handler,

			  IRQF_ONESHOT | IRQF_SHARED,

			  "cache_hwmon", df);

	if (ret < 0) {

		pr_err("Unable to register interrupt handler! (%d)\n", ret);

		goto req_irq_fail;

	}



	ret = sysfs_create_group(&df->dev.kobj, &dev_attr_group);

	if (ret < 0) {

		pr_err("Error creating sys entries! (%d)\n", ret);

		goto sysfs_fail;

	}



	return 0;



sysfs_fail:

	disable_irq(hw->irq);

	free_irq(hw->irq, df);

req_irq_fail:

	devfreq_monitor_stop(df);

	hw->stop_hwmon(df);

	return ret;

}



static void stop_monitoring(struct devfreq *df)

{

	sysfs_remove_group(&df->dev.kobj, &dev_attr_group);

	disable_irq(hw->irq);

	free_irq(hw->irq, df);

	devfreq_monitor_stop(df);

	hw->stop_hwmon(df);

}



static int devfreq_cache_hwmon_ev_handler(struct devfreq *df,

					unsigned int event, void *data)

{

	int ret;



	switch (event) {

	case DEVFREQ_GOV_START:

		sample_ms = df->profile->polling_ms;

		sample_ms = max(MIN_MS, sample_ms);

		sample_ms = min(MAX_MS, sample_ms);

		df->profile->polling_ms = sample_ms;



		ret = start_monitoring(df);

		if (ret < 0)

			return ret;



		pr_debug("Enabled Cache HW monitor governor\n");

		break;

	case DEVFREQ_GOV_STOP:

		stop_monitoring(df);

		pr_debug("Disabled Cache HW monitor governor\n");

		break;

	case DEVFREQ_GOV_INTERVAL:

		sample_ms = *(unsigned int *)data;

		sample_ms = max(MIN_MS, sample_ms);

		sample_ms = min(MAX_MS, sample_ms);

		devfreq_interval_update(df, &sample_ms);

		break;

	}



	return 0;

}



static struct devfreq_governor devfreq_cache_hwmon = {

	.name = "cache_hwmon",

	.get_target_freq = devfreq_cache_hwmon_get_freq,

	.event_handler = devfreq_cache_hwmon_ev_handler,

};



int register_cache_hwmon(struct cache_hwmon *hwmon)

{

	int ret;



	hw = hwmon;

	ret = devfreq_add_governor(&devfreq_cache_hwmon);

	if (ret < 0) {

		pr_err("devfreq governor registration failed: %d\n", ret);

		return ret;

	}



	return 0;

}



MODULE_DESCRIPTION("HW monitor based cache freq driver");

MODULE_LICENSE("GPL v2");

drivers/devfreq/governor_cache_hwmon.h

0 → 100644
+39 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright (c) 2014, 2016, 2019, The Linux Foundation. All rights reserved.

 */



#ifndef _GOVERNOR_CACHE_HWMON_H

#define _GOVERNOR_CACHE_HWMON_H



#include <linux/kernel.h>

#include <linux/devfreq.h>



struct mrps_stats {

	unsigned long	high;

	unsigned long	med;

	unsigned long	low;

	unsigned int	busy_percent;

};



struct cache_hwmon {

	int		(*start_hwmon)(struct devfreq *df,

					struct mrps_stats *mrps);

	void		(*stop_hwmon)(struct devfreq *df);

	bool		(*is_valid_irq)(struct devfreq *df);

	unsigned long	(*meas_mrps_and_set_irq)(struct devfreq *df,

					unsigned int tol, unsigned int us,

					struct mrps_stats *mrps);

	int		irq;

};



#ifdef CONFIG_DEVFREQ_GOV_QCOM_CACHE_HWMON

int register_cache_hwmon(struct cache_hwmon *hwmon);

#else

static inline int register_cache_hwmon(struct cache_hwmon *hwmon)

{

	return 0;

}

#endif



#endif /* _GOVERNOR_CACHE_HWMON_H */