Merge "devfreq: Weight stall cycles more for GPU bus DCVS" (c51d2a37) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/devfreq/Kconfig

+18 −0

Original line number	Diff line number	Diff line
		@@ -122,6 +122,24 @@ config DEVFREQ_GOV_MEMLAT

		comment "DEVFREQ Drivers"

		config DEVFREQ_GOV_QCOM_ADRENO_TZ
		tristate "Qualcomm Technologies Inc Adreno Trustzone"
		depends on QCOM_KGSL && QCOM_SCM
		help
		Trustzone based governor for the Adreno GPU. Sets
		the frequency using a "on-demand" algorithm. This
		governor is unlikely to be useful for other
		devices.

		config DEVFREQ_GOV_QCOM_GPUBW_MON
		tristate "GPU BW voting governor"
		depends on DEVFREQ_GOV_QCOM_ADRENO_TZ
		help
		This governor works together with Adreno Trustzone governor,
		and select bus frequency votes using an "on-demand" alorithm.
		This governor is unlikely to be useful for non-Adreno
		devices.

		config ARM_EXYNOS_BUS_DEVFREQ
		tristate "ARM EXYNOS Generic Memory Bus DEVFREQ Driver"
		depends on ARCH_EXYNOS \|\| COMPILE_TEST

drivers/devfreq/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -11,6 +11,8 @@ obj-$(CONFIG_ARM_MEMLAT_MON) += arm-memlat-mon.o
		obj-$(CONFIG_DEVFREQ_GOV_QCOM_BW_HWMON) += governor_bw_hwmon.o
		obj-$(CONFIG_DEVFREQ_GOV_QCOM_CACHE_HWMON) += governor_cache_hwmon.o
		obj-$(CONFIG_DEVFREQ_GOV_MEMLAT) += governor_memlat.o
		obj-$(CONFIG_DEVFREQ_GOV_QCOM_ADRENO_TZ) += governor_msm_adreno_tz.o
		obj-$(CONFIG_DEVFREQ_GOV_QCOM_GPUBW_MON) += governor_bw_vbif.o

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

drivers/devfreq/devfreq_trace.h

0 → 100644

+36 −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.
		*/

		#if !defined(_DEVFREQ_TRACE_H) \|\| defined(TRACE_HEADER_MULTI_READ)
		#define _DEVFREQ_TRACE_H

		#undef TRACE_SYSTEM
		#define TRACE_SYSTEM devfreq
		#undef TRACE_INCLUDE_PATH
		#define TRACE_INCLUDE_PATH .
		#undef TRACE_INCLUDE_FILE
		#define TRACE_INCLUDE_FILE devfreq_trace

		#include <linux/tracepoint.h>

		TRACE_EVENT(devfreq_msg,
		TP_PROTO(const char *msg),
		TP_ARGS(msg),
		TP_STRUCT__entry(
		__string(msg, msg)
		),
		TP_fast_assign(
		__assign_str(msg, msg);
		),
		TP_printk(
		"%s", __get_str(msg)
		)
		);

		#endif /* _DEVFREQ_TRACE_H */

		/* This part must be outside protection */
		#include <trace/define_trace.h>

drivers/devfreq/governor_bw_vbif.c

0 → 100644

+133 −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.
		*/

		#include <linux/devfreq.h>
		#include <linux/module.h>
		#include "governor.h"

		unsigned long (*extern_get_bw)(void) = NULL;
		unsigned long *dev_ab;
		static unsigned long dev_ib;

		DEFINE_MUTEX(df_lock);
		static struct devfreq *df;

		/*
		* This function is 'get_target_freq' API for the governor.
		* It just calls an external function that should be registered
		* by KGSL driver to get and return a value for frequency.
		*/
		static int devfreq_vbif_get_freq(struct devfreq *df,
		unsigned long *freq)
		{
		/* If the IB isn't set yet, check if it should be non-zero. */
		if (!dev_ib && extern_get_bw) {
		dev_ib = extern_get_bw();
		if (dev_ab)
		*dev_ab = dev_ib / 4;
		}

		*freq = dev_ib;
		return 0;
		}

		/*
		* Registers a function to be used to request a frequency
		* value from legacy vbif based bus bandwidth governor.
		* This function is called by KGSL driver.
		*/
		void devfreq_vbif_register_callback(void *p)
		{
		extern_get_bw = p;
		}

		int devfreq_vbif_update_bw(unsigned long ib, unsigned long ab)
		{
		int ret = 0;

		mutex_lock(&df_lock);
		if (df) {
		mutex_lock(&df->lock);
		dev_ib = ib;
		*dev_ab = ab;
		ret = update_devfreq(df);
		mutex_unlock(&df->lock);
		}
		mutex_unlock(&df_lock);
		return ret;
		}

		static int devfreq_vbif_ev_handler(struct devfreq *devfreq,
		unsigned int event, void *data)
		{
		int ret;
		struct devfreq_dev_status stat;

		switch (event) {
		case DEVFREQ_GOV_START:
		mutex_lock(&df_lock);
		df = devfreq;
		if (df->profile->get_dev_status &&
		!df->profile->get_dev_status(df->dev.parent, &stat) &&
		stat.private_data)
		dev_ab = stat.private_data;
		else
		pr_warn("Device doesn't take AB votes!\n");

		mutex_unlock(&df_lock);

		ret = devfreq_vbif_update_bw(0, 0);
		if (ret) {
		pr_err("Unable to update BW! Gov start failed!\n");
		return ret;
		}
		/*
		* Normally at this point governors start the polling with
		* devfreq_monitor_start(df);
		* This governor doesn't poll, but expect external calls
		* of its devfreq_vbif_update_bw() function
		*/
		pr_debug("Enabled MSM VBIF governor\n");
		break;

		case DEVFREQ_GOV_STOP:
		mutex_lock(&df_lock);
		df = NULL;
		mutex_unlock(&df_lock);

		pr_debug("Disabled MSM VBIF governor\n");
		break;
		}

		return 0;
		}

		static struct devfreq_governor devfreq_vbif = {
		.name = "bw_vbif",
		.get_target_freq = devfreq_vbif_get_freq,
		.event_handler = devfreq_vbif_ev_handler,
		};

		static int __init devfreq_vbif_init(void)
		{
		return devfreq_add_governor(&devfreq_vbif);
		}
		subsys_initcall(devfreq_vbif_init);

		static void __exit devfreq_vbif_exit(void)
		{
		int ret;

		ret = devfreq_remove_governor(&devfreq_vbif);
		if (ret)
		pr_err("%s: failed remove governor %d\n", __func__, ret);

		}
		module_exit(devfreq_vbif_exit);

		MODULE_DESCRIPTION("VBIF based GPU bus BW voting governor");
		MODULE_LICENSE("GPL v2");

drivers/devfreq/governor_gpubw_mon.c

0 → 100644

+266 −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.
		*/

		#include <linux/devfreq.h>
		#include <linux/module.h>
		#include <linux/msm_adreno_devfreq.h>
		#include <linux/slab.h>

		#include "devfreq_trace.h"
		#include "governor.h"

		#define MIN_BUSY 1000
		#define LONG_FLOOR 50000
		#define HIST 5
		#define TARGET 80
		#define CAP 75
		#define WAIT_THRESHOLD 10
		/* AB vote is in multiple of BW_STEP Mega bytes */
		#define BW_STEP 160

		static void _update_cutoff(struct devfreq_msm_adreno_tz_data *priv,
		unsigned int norm_max)
		{
		int i;

		priv->bus.max = norm_max;
		for (i = 0; i < priv->bus.num; i++) {
		priv->bus.up[i] = priv->bus.p_up[i] * norm_max / 100;
		priv->bus.down[i] = priv->bus.p_down[i] * norm_max / 100;
		}
		}

		static inline int devfreq_get_freq_level(struct devfreq *devfreq,
		unsigned long freq)
		{
		int lev;

		for (lev = 0; lev < devfreq->profile->max_state; lev++)
		if (freq == devfreq->profile->freq_table[lev])
		return lev;

		return -EINVAL;
		}

		static int devfreq_gpubw_get_target(struct devfreq *df,
		unsigned long *freq)
		{

		struct devfreq_msm_adreno_tz_data *priv = df->data;
		struct msm_busmon_extended_profile *bus_profile = container_of(
		(df->profile),
		struct msm_busmon_extended_profile,
		profile);
		struct devfreq_dev_status stats;
		struct xstats b;
		int result;
		int level = 0;
		int act_level;
		int norm_max_cycles;
		int norm_cycles;
		int wait_active_percent;
		int gpu_percent;
		/*
		* Normalized AB should at max usage be the gpu_bimc frequency in MHz.
		* Start with a reasonable value and let the system push it up to max.
		*/
		static int norm_ab_max = 300;
		int norm_ab;
		unsigned long ab_mbytes = 0;

		if (priv == NULL)
		return 0;

		stats.private_data = &b;

		result = df->profile->get_dev_status(df->dev.parent, &stats);

		*freq = stats.current_frequency;

		priv->bus.total_time += stats.total_time;
		priv->bus.gpu_time += stats.busy_time;
		priv->bus.ram_time += b.ram_time;
		priv->bus.ram_wait += b.ram_wait;

		level = devfreq_get_freq_level(df, stats.current_frequency);

		if (priv->bus.total_time < LONG_FLOOR)
		return result;

		norm_max_cycles = (unsigned int)(priv->bus.ram_time) /
		(unsigned int) priv->bus.total_time;
		norm_cycles = (unsigned int)(priv->bus.ram_time + priv->bus.ram_wait) /
		(unsigned int) priv->bus.total_time;
		wait_active_percent = (100 * (unsigned int)priv->bus.ram_wait) /
		(unsigned int) priv->bus.ram_time;
		gpu_percent = (100 * (unsigned int)priv->bus.gpu_time) /
		(unsigned int) priv->bus.total_time;

		/*
		* If there's a new high watermark, update the cutoffs and send the
		* FAST hint. Otherwise check the current value against the current
		* cutoffs.
		*/
		if (norm_max_cycles > priv->bus.max) {
		_update_cutoff(priv, norm_max_cycles);
		bus_profile->flag = DEVFREQ_FLAG_FAST_HINT;
		} else {
		/* GPU votes for IB not AB so don't under vote the system */
		norm_cycles = (100 * norm_cycles) / TARGET;
		act_level = priv->bus.index[level] + b.mod;
		act_level = (act_level < 0) ? 0 : act_level;
		act_level = (act_level >= priv->bus.num) ?
		(priv->bus.num - 1) : act_level;
		if ((norm_cycles > priv->bus.up[act_level] \|\|
		wait_active_percent > WAIT_THRESHOLD) &&
		gpu_percent > CAP)
		bus_profile->flag = DEVFREQ_FLAG_FAST_HINT;
		else if (norm_cycles < priv->bus.down[act_level] && level)
		bus_profile->flag = DEVFREQ_FLAG_SLOW_HINT;
		}

		/* Calculate the AB vote based on bus width if defined */
		if (priv->bus.width) {
		norm_ab = (unsigned int)priv->bus.ram_time /
		(unsigned int) priv->bus.total_time;
		/* Calculate AB in Mega Bytes and roundup in BW_STEP */
		ab_mbytes = (norm_ab * priv->bus.width * 1000000ULL) >> 20;
		bus_profile->ab_mbytes = roundup(ab_mbytes, BW_STEP);
		} else if (bus_profile->flag) {
		/* Re-calculate the AB percentage for a new IB vote */
		norm_ab = (unsigned int)priv->bus.ram_time /
		(unsigned int) priv->bus.total_time;
		if (norm_ab > norm_ab_max)
		norm_ab_max = norm_ab;
		bus_profile->percent_ab = (100 * norm_ab) / norm_ab_max;
		}

		priv->bus.total_time = 0;
		priv->bus.gpu_time = 0;
		priv->bus.ram_time = 0;
		priv->bus.ram_wait = 0;

		return result;
		}

		static int gpubw_start(struct devfreq *devfreq)
		{
		struct devfreq_msm_adreno_tz_data *priv;

		struct msm_busmon_extended_profile *bus_profile = container_of(
		(devfreq->profile),
		struct msm_busmon_extended_profile,
		profile);
		unsigned int t1, t2 = 2 * HIST;
		int i, bus_size;


		devfreq->data = bus_profile->private_data;
		priv = devfreq->data;

		bus_size = sizeof(u32) * priv->bus.num;
		priv->bus.up = kzalloc(bus_size, GFP_KERNEL);
		priv->bus.down = kzalloc(bus_size, GFP_KERNEL);
		priv->bus.p_up = kzalloc(bus_size, GFP_KERNEL);
		priv->bus.p_down = kzalloc(bus_size, GFP_KERNEL);
		if (priv->bus.up == NULL \|\| priv->bus.down == NULL \|\|
		priv->bus.p_up == NULL \|\| priv->bus.p_down == NULL)
		return -ENOMEM;

		/* Set up the cut-over percentages for the bus calculation. */
		for (i = 0; i < priv->bus.num; i++) {
		t1 = (u32)(100 * priv->bus.ib[i]) /
		(u32)priv->bus.ib[priv->bus.num - 1];
		priv->bus.p_up[i] = t1 - HIST;
		priv->bus.p_down[i] = t2 - 2 * HIST;
		t2 = t1;
		}
		/* Set the upper-most and lower-most bounds correctly. */
		priv->bus.p_down[0] = 0;
		priv->bus.p_down[1] = (priv->bus.p_down[1] > (2 * HIST)) ?
		priv->bus.p_down[1] : (2 * HIST);
		if (priv->bus.num >= 1)
		priv->bus.p_up[priv->bus.num - 1] = 100;
		_update_cutoff(priv, priv->bus.max);

		return 0;
		}

		static int gpubw_stop(struct devfreq *devfreq)
		{
		struct devfreq_msm_adreno_tz_data *priv = devfreq->data;

		if (priv) {
		kfree(priv->bus.up);
		kfree(priv->bus.down);
		kfree(priv->bus.p_up);
		kfree(priv->bus.p_down);
		}
		devfreq->data = NULL;
		return 0;
		}

		static int devfreq_gpubw_event_handler(struct devfreq *devfreq,
		unsigned int event, void *data)
		{
		int result = 0;
		unsigned long freq;

		mutex_lock(&devfreq->lock);
		freq = devfreq->previous_freq;
		switch (event) {
		case DEVFREQ_GOV_START:
		result = gpubw_start(devfreq);
		break;
		case DEVFREQ_GOV_STOP:
		result = gpubw_stop(devfreq);
		break;
		case DEVFREQ_GOV_RESUME:
		/* TODO ..... */
		/* ret = update_devfreq(devfreq); */
		break;
		case DEVFREQ_GOV_SUSPEND:
		{
		struct devfreq_msm_adreno_tz_data *priv = devfreq->data;

		priv->bus.total_time = 0;
		priv->bus.gpu_time = 0;
		priv->bus.ram_time = 0;
		}
		break;
		default:
		result = 0;
		break;
		}
		mutex_unlock(&devfreq->lock);
		return result;
		}

		static struct devfreq_governor devfreq_gpubw = {
		.name = "gpubw_mon",
		.get_target_freq = devfreq_gpubw_get_target,
		.event_handler = devfreq_gpubw_event_handler,
		};

		static int __init devfreq_gpubw_init(void)
		{
		return devfreq_add_governor(&devfreq_gpubw);
		}
		subsys_initcall(devfreq_gpubw_init);

		static void __exit devfreq_gpubw_exit(void)
		{
		int ret;

		ret = devfreq_remove_governor(&devfreq_gpubw);
		if (ret)
		pr_err("%s: failed remove governor %d\n", __func__, ret);

		}
		module_exit(devfreq_gpubw_exit);

		MODULE_DESCRIPTION("GPU bus bandwidth voting driver. Uses VBIF counters");
		MODULE_LICENSE("GPL v2");