Commit cc19b05e authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branches 'pm-devfreq' and 'pm-tools' 

* pm-devfreq:
  PM / devfreq: remove redundant null pointer check before kfree
  PM / devfreq: stopping the governor before device_unregister()
  PM / devfreq: Convert to using %pOFn instead of device_node.name
  PM / devfreq: Make update_devfreq() public
  PM / devfreq: Don't adjust to user limits in governors
  PM / devfreq: Fix handling of min/max_freq == 0
  PM / devfreq: Drop custom MIN/MAX macros
  PM / devfreq: Fix devfreq_add_device() when drivers are built as modules.

* pm-tools:
  PM / tools: sleepgraph and bootgraph: upgrade to v5.2
  PM / tools: sleepgraph: first batch of v5.2 changes
  cpupower: Fix coredump on VMWare
  cpupower: Fix AMD Family 0x17 msr_pstate size
  cpupower: remove stringop-truncation waring
parents 5d113aa6 8fa38749 9a69e3ac

drivers/devfreq/devfreq.c

+88 −30
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
 */



#include <linux/kernel.h>

#include <linux/kmod.h>

#include <linux/sched.h>

#include <linux/errno.h>

#include <linux/err.h>
@@ -28,9 +29,6 @@ 
#include <linux/of.h>

#include "governor.h"



#define MAX(a,b)	((a > b) ? a : b)

#define MIN(a,b)	((a < b) ? a : b)



static struct class *devfreq_class;



/*
@@ -221,6 +219,49 @@ static struct devfreq_governor *find_devfreq_governor(const char *name) 
	return ERR_PTR(-ENODEV);

}



/**

 * try_then_request_governor() - Try to find the governor and request the

 *                               module if is not found.

 * @name:	name of the governor

 *

 * Search the list of devfreq governors and request the module and try again

 * if is not found. This can happen when both drivers (the governor driver

 * and the driver that call devfreq_add_device) are built as modules.

 * devfreq_list_lock should be held by the caller. Returns the matched

 * governor's pointer.

 */

static struct devfreq_governor *try_then_request_governor(const char *name)

{

	struct devfreq_governor *governor;

	int err = 0;



	if (IS_ERR_OR_NULL(name)) {

		pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);

		return ERR_PTR(-EINVAL);

	}

	WARN(!mutex_is_locked(&devfreq_list_lock),

	     "devfreq_list_lock must be locked.");



	governor = find_devfreq_governor(name);

	if (IS_ERR(governor)) {

		mutex_unlock(&devfreq_list_lock);



		if (!strncmp(name, DEVFREQ_GOV_SIMPLE_ONDEMAND,

			     DEVFREQ_NAME_LEN))

			err = request_module("governor_%s", "simpleondemand");

		else

			err = request_module("governor_%s", name);

		/* Restore previous state before return */

		mutex_lock(&devfreq_list_lock);

		if (err)

			return NULL;



		governor = find_devfreq_governor(name);

	}



	return governor;

}



static int devfreq_notify_transition(struct devfreq *devfreq,

		struct devfreq_freqs *freqs, unsigned int state)

{
@@ -280,14 +321,14 @@ int update_devfreq(struct devfreq *devfreq) 
	 * max_freq

	 * min_freq

	 */

	max_freq = MIN(devfreq->scaling_max_freq, devfreq->max_freq);

	min_freq = MAX(devfreq->scaling_min_freq, devfreq->min_freq);

	max_freq = min(devfreq->scaling_max_freq, devfreq->max_freq);

	min_freq = max(devfreq->scaling_min_freq, devfreq->min_freq);



	if (min_freq && freq < min_freq) {

	if (freq < min_freq) {

		freq = min_freq;

		flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */

	}

	if (max_freq && freq > max_freq) {

	if (freq > max_freq) {

		freq = max_freq;

		flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */

	}
@@ -534,10 +575,6 @@ static void devfreq_dev_release(struct device *dev) 
	list_del(&devfreq->node);

	mutex_unlock(&devfreq_list_lock);



	if (devfreq->governor)

		devfreq->governor->event_handler(devfreq,

						 DEVFREQ_GOV_STOP, NULL);



	if (devfreq->profile->exit)

		devfreq->profile->exit(devfreq->dev.parent);
@@ -646,9 +683,8 @@ struct devfreq *devfreq_add_device(struct device *dev, 
	mutex_unlock(&devfreq->lock);



	mutex_lock(&devfreq_list_lock);

	list_add(&devfreq->node, &devfreq_list);



	governor = find_devfreq_governor(devfreq->governor_name);

	governor = try_then_request_governor(devfreq->governor_name);

	if (IS_ERR(governor)) {

		dev_err(dev, "%s: Unable to find governor for the device\n",

			__func__);
@@ -664,18 +700,19 @@ struct devfreq *devfreq_add_device(struct device *dev, 
			__func__);

		goto err_init;

	}



	list_add(&devfreq->node, &devfreq_list);



	mutex_unlock(&devfreq_list_lock);



	return devfreq;



err_init:

	list_del(&devfreq->node);

	mutex_unlock(&devfreq_list_lock);



	device_unregister(&devfreq->dev);

	devfreq_remove_device(devfreq);

	devfreq = NULL;

err_dev:

	if (devfreq)

	kfree(devfreq);

err_out:

	return ERR_PTR(err);
@@ -693,6 +730,9 @@ int devfreq_remove_device(struct devfreq *devfreq) 
	if (!devfreq)

		return -EINVAL;



	if (devfreq->governor)

		devfreq->governor->event_handler(devfreq,

						 DEVFREQ_GOV_STOP, NULL);

	device_unregister(&devfreq->dev);



	return 0;
@@ -991,7 +1031,7 @@ static ssize_t governor_store(struct device *dev, struct device_attribute *attr, 
		return -EINVAL;



	mutex_lock(&devfreq_list_lock);

	governor = find_devfreq_governor(str_governor);

	governor = try_then_request_governor(str_governor);

	if (IS_ERR(governor)) {

		ret = PTR_ERR(governor);

		goto out;
@@ -1126,18 +1166,27 @@ static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr, 
	struct devfreq *df = to_devfreq(dev);

	unsigned long value;

	int ret;

	unsigned long max;



	ret = sscanf(buf, "%lu", &value);

	if (ret != 1)

		return -EINVAL;



	mutex_lock(&df->lock);

	max = df->max_freq;

	if (value && max && value > max) {



	if (value) {

		if (value > df->max_freq) {

			ret = -EINVAL;

			goto unlock;

		}

	} else {

		unsigned long *freq_table = df->profile->freq_table;



		/* Get minimum frequency according to sorting order */

		if (freq_table[0] < freq_table[df->profile->max_state - 1])

			value = freq_table[0];

		else

			value = freq_table[df->profile->max_state - 1];

	}



	df->min_freq = value;

	update_devfreq(df);
@@ -1152,7 +1201,7 @@ static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr, 
{

	struct devfreq *df = to_devfreq(dev);



	return sprintf(buf, "%lu\n", MAX(df->scaling_min_freq, df->min_freq));

	return sprintf(buf, "%lu\n", max(df->scaling_min_freq, df->min_freq));

}



static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
@@ -1161,18 +1210,27 @@ static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr, 
	struct devfreq *df = to_devfreq(dev);

	unsigned long value;

	int ret;

	unsigned long min;



	ret = sscanf(buf, "%lu", &value);

	if (ret != 1)

		return -EINVAL;



	mutex_lock(&df->lock);

	min = df->min_freq;

	if (value && min && value < min) {



	if (value) {

		if (value < df->min_freq) {

			ret = -EINVAL;

			goto unlock;

		}

	} else {

		unsigned long *freq_table = df->profile->freq_table;



		/* Get maximum frequency according to sorting order */

		if (freq_table[0] < freq_table[df->profile->max_state - 1])

			value = freq_table[df->profile->max_state - 1];

		else

			value = freq_table[0];

	}



	df->max_freq = value;

	update_devfreq(df);
@@ -1188,7 +1246,7 @@ static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr, 
{

	struct devfreq *df = to_devfreq(dev);



	return sprintf(buf, "%lu\n", MIN(df->scaling_max_freq, df->max_freq));

	return sprintf(buf, "%lu\n", min(df->scaling_max_freq, df->max_freq));

}

static DEVICE_ATTR_RW(max_freq);

drivers/devfreq/event/exynos-ppmu.c

+2 −2
Original line number Diff line number Diff line
@@ -535,8 +535,8 @@ static int of_get_devfreq_events(struct device_node *np, 


		if (i == ARRAY_SIZE(ppmu_events)) {

			dev_warn(dev,

				"don't know how to configure events : %s\n",

				node->name);

				"don't know how to configure events : %pOFn\n",

				node);

			continue;

		}

drivers/devfreq/governor.h

+3 −3
Original line number Diff line number Diff line
@@ -25,6 +25,9 @@ 
#define DEVFREQ_GOV_SUSPEND			0x4

#define DEVFREQ_GOV_RESUME			0x5



#define DEVFREQ_MIN_FREQ			0

#define DEVFREQ_MAX_FREQ			ULONG_MAX



/**

 * struct devfreq_governor - Devfreq policy governor

 * @node:		list node - contains registered devfreq governors
@@ -54,9 +57,6 @@ struct devfreq_governor { 
				unsigned int event, void *data);

};



/* Caution: devfreq->lock must be locked before calling update_devfreq */

extern int update_devfreq(struct devfreq *devfreq);



extern void devfreq_monitor_start(struct devfreq *devfreq);

extern void devfreq_monitor_stop(struct devfreq *devfreq);

extern void devfreq_monitor_suspend(struct devfreq *devfreq);

drivers/devfreq/governor_performance.c

+1 −4
Original line number Diff line number Diff line
@@ -20,10 +20,7 @@ static int devfreq_performance_func(struct devfreq *df, 
	 * target callback should be able to get floor value as

	 * said in devfreq.h

	 */

	if (!df->max_freq)

		*freq = UINT_MAX;

	else

		*freq = df->max_freq;

	*freq = DEVFREQ_MAX_FREQ;

	return 0;

}

drivers/devfreq/governor_powersave.c

+1 −1
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@ static int devfreq_powersave_func(struct devfreq *df, 
	 * target callback should be able to get ceiling value as

	 * said in devfreq.h

	 */

	*freq = df->min_freq;

	*freq = DEVFREQ_MIN_FREQ;

	return 0;

}