PM / OPP: Move cpufreq specific OPP functions out of generic OPP library (a0dd7b79) · Commits · e / devices / android_kernel_samsung_universal8890

Documentation/cpu-freq/core.txt

+29 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ Contents:
		---------
		1. CPUFreq core and interfaces
		2. CPUFreq notifiers
		3. CPUFreq Table Generation with Operating Performance Point (OPP)

		1. General Information
		=======================
		@@ -92,3 +93,31 @@ values:
		cpu - number of the affected CPU
		old - old frequency
		new - new frequency

		3. CPUFreq Table Generation with Operating Performance Point (OPP)
		==================================================================
		For details about OPP, see Documentation/power/opp.txt

		dev_pm_opp_init_cpufreq_table - cpufreq framework typically is initialized with
		cpufreq_frequency_table_cpuinfo which is provided with the list of
		frequencies that are available for operation. This function provides
		a ready to use conversion routine to translate the OPP layer's internal
		information about the available frequencies into a format readily
		providable to cpufreq.

		WARNING: Do not use this function in interrupt context.

		Example:
		soc_pm_init()
		{
		/* Do things */
		r = dev_pm_opp_init_cpufreq_table(dev, &freq_table);
		if (!r)
		cpufreq_frequency_table_cpuinfo(policy, freq_table);
		/* Do other things */
		}

		NOTE: This function is available only if CONFIG_CPU_FREQ is enabled in
		addition to CONFIG_PM_OPP.

		dev_pm_opp_free_cpufreq_table - Free up the table allocated by dev_pm_opp_init_cpufreq_table

Documentation/power/opp.txt

+5 −35

Original line number	Diff line number	Diff line
		@@ -10,8 +10,7 @@ Contents
		3. OPP Search Functions
		4. OPP Availability Control Functions
		5. OPP Data Retrieval Functions
		6. Cpufreq Table Generation
		7. Data Structures
		6. Data Structures

		1. Introduction
		===============
		@@ -72,7 +71,6 @@ operations until that OPP could be re-enabled if possible.
		OPP library facilitates this concept in it's implementation. The following
		operational functions operate only on available opps:
		opp_find_freq_{ceil, floor}, dev_pm_opp_get_voltage, dev_pm_opp_get_freq, dev_pm_opp_get_opp_count
		and dev_pm_opp_init_cpufreq_table

		dev_pm_opp_find_freq_exact is meant to be used to find the opp pointer which can then
		be used for dev_pm_opp_enable/disable functions to make an opp available as required.
		@@ -96,10 +94,9 @@ using RCU read locks. The opp_find_freq_{exact,ceil,floor},
		opp_get_{voltage, freq, opp_count} fall into this category.

		opp_{add,enable,disable} are updaters which use mutex and implement it's own
		RCU locking mechanisms. dev_pm_opp_init_cpufreq_table acts as an updater and uses
		mutex to implment RCU updater strategy. These functions should NOT be called
		under RCU locks and other contexts that prevent blocking functions in RCU or
		mutex operations from working.
		RCU locking mechanisms. These functions should NOT be called under RCU locks
		and other contexts that prevent blocking functions in RCU or mutex operations
		from working.

		2. Initial OPP List Registration
		================================
		@@ -311,34 +308,7 @@ dev_pm_opp_get_opp_count - Retrieve the number of available opps for a device
		/* Do other things */
		}

		6. Cpufreq Table Generation
		===========================
		dev_pm_opp_init_cpufreq_table - cpufreq framework typically is initialized with
		cpufreq_frequency_table_cpuinfo which is provided with the list of
		frequencies that are available for operation. This function provides
		a ready to use conversion routine to translate the OPP layer's internal
		information about the available frequencies into a format readily
		providable to cpufreq.

		WARNING: Do not use this function in interrupt context.

		Example:
		soc_pm_init()
		{
		/* Do things */
		r = dev_pm_opp_init_cpufreq_table(dev, &freq_table);
		if (!r)
		cpufreq_frequency_table_cpuinfo(policy, freq_table);
		/* Do other things */
		}

		NOTE: This function is available only if CONFIG_CPU_FREQ is enabled in
		addition to CONFIG_PM as power management feature is required to
		dynamically scale voltage and frequency in a system.

		dev_pm_opp_free_cpufreq_table - Free up the table allocated by dev_pm_opp_init_cpufreq_table

		7. Data Structures
		6. Data Structures
		==================
		Typically an SoC contains multiple voltage domains which are variable. Each
		domain is represented by a device pointer. The relationship to OPP can be

drivers/base/power/opp.c

+0 −92

Original line number	Diff line number	Diff line
		@@ -15,7 +15,6 @@
		#include <linux/errno.h>
		#include <linux/err.h>
		#include <linux/slab.h>
		#include <linux/cpufreq.h>
		#include <linux/device.h>
		#include <linux/list.h>
		#include <linux/rculist.h>
		@@ -596,97 +595,6 @@ int dev_pm_opp_disable(struct device *dev, unsigned long freq)
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_disable);

		#ifdef CONFIG_CPU_FREQ
		/**
		* dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
		* @dev: device for which we do this operation
		* @table: Cpufreq table returned back to caller
		*
		* Generate a cpufreq table for a provided device- this assumes that the
		* opp list is already initialized and ready for usage.
		*
		* This function allocates required memory for the cpufreq table. It is
		* expected that the caller does the required maintenance such as freeing
		* the table as required.
		*
		* Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
		* if no memory available for the operation (table is not populated), returns 0
		* if successful and table is populated.
		*
		* WARNING: It is important for the callers to ensure refreshing their copy of
		* the table if any of the mentioned functions have been invoked in the interim.
		*
		* Locking: The internal device_opp and opp structures are RCU protected.
		* Since we just use the regular accessor functions to access the internal data
		* structures, we use RCU read lock inside this function. As a result, users of
		* this function DONOT need to use explicit locks for invoking.
		*/
		int dev_pm_opp_init_cpufreq_table(struct device *dev,
		struct cpufreq_frequency_table **table)
		{
		struct dev_pm_opp *opp;
		struct cpufreq_frequency_table *freq_table = NULL;
		int i, max_opps, ret = 0;
		unsigned long rate;

		rcu_read_lock();

		max_opps = dev_pm_opp_get_opp_count(dev);
		if (max_opps <= 0) {
		ret = max_opps ? max_opps : -ENODATA;
		goto out;
		}

		freq_table = kzalloc(sizeof(freq_table) (max_opps + 1), GFP_KERNEL);
		if (!freq_table) {
		ret = -ENOMEM;
		goto out;
		}

		for (i = 0, rate = 0; i < max_opps; i++, rate++) {
		/* find next rate */
		opp = dev_pm_opp_find_freq_ceil(dev, &rate);
		if (IS_ERR(opp)) {
		ret = PTR_ERR(opp);
		goto out;
		}
		freq_table[i].driver_data = i;
		freq_table[i].frequency = rate / 1000;
		}

		freq_table[i].driver_data = i;
		freq_table[i].frequency = CPUFREQ_TABLE_END;

		*table = &freq_table[0];

		out:
		rcu_read_unlock();
		if (ret)
		kfree(freq_table);

		return ret;
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);

		/**
		* dev_pm_opp_free_cpufreq_table() - free the cpufreq table
		* @dev: device for which we do this operation
		* @table: table to free
		*
		* Free up the table allocated by dev_pm_opp_init_cpufreq_table
		*/
		void dev_pm_opp_free_cpufreq_table(struct device *dev,
		struct cpufreq_frequency_table **table)
		{
		if (!table)
		return;

		kfree(*table);
		*table = NULL;
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
		#endif /* CONFIG_CPU_FREQ */

		/**
		* dev_pm_opp_get_notifier() - find notifier_head of the device with opp
		* @dev: device pointer used to lookup device OPPs.

drivers/cpufreq/Makefile

+2 −0

Original line number	Diff line number	Diff line
		# CPUfreq core
		obj-$(CONFIG_CPU_FREQ) += cpufreq.o freq_table.o
		obj-$(CONFIG_PM_OPP) += cpufreq_opp.o

		# CPUfreq stats
		obj-$(CONFIG_CPU_FREQ_STAT) += cpufreq_stats.o

drivers/cpufreq/cpufreq_opp.c

0 → 100644

+110 −0

Original line number	Diff line number	Diff line
		/*
		* Generic OPP helper interface for CPUFreq drivers
		*
		* Copyright (C) 2009-2014 Texas Instruments Incorporated.
		* Nishanth Menon
		* Romit Dasgupta
		* Kevin Hilman
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*/
		#include <linux/cpufreq.h>
		#include <linux/device.h>
		#include <linux/err.h>
		#include <linux/errno.h>
		#include <linux/export.h>
		#include <linux/kernel.h>
		#include <linux/pm_opp.h>
		#include <linux/rcupdate.h>
		#include <linux/slab.h>

		/**
		* dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
		* @dev: device for which we do this operation
		* @table: Cpufreq table returned back to caller
		*
		* Generate a cpufreq table for a provided device- this assumes that the
		* opp list is already initialized and ready for usage.
		*
		* This function allocates required memory for the cpufreq table. It is
		* expected that the caller does the required maintenance such as freeing
		* the table as required.
		*
		* Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
		* if no memory available for the operation (table is not populated), returns 0
		* if successful and table is populated.
		*
		* WARNING: It is important for the callers to ensure refreshing their copy of
		* the table if any of the mentioned functions have been invoked in the interim.
		*
		* Locking: The internal device_opp and opp structures are RCU protected.
		* Since we just use the regular accessor functions to access the internal data
		* structures, we use RCU read lock inside this function. As a result, users of
		* this function DONOT need to use explicit locks for invoking.
		*/
		int dev_pm_opp_init_cpufreq_table(struct device *dev,
		struct cpufreq_frequency_table **table)
		{
		struct dev_pm_opp *opp;
		struct cpufreq_frequency_table *freq_table = NULL;
		int i, max_opps, ret = 0;
		unsigned long rate;

		rcu_read_lock();

		max_opps = dev_pm_opp_get_opp_count(dev);
		if (max_opps <= 0) {
		ret = max_opps ? max_opps : -ENODATA;
		goto out;
		}

		freq_table = kzalloc(sizeof(freq_table) (max_opps + 1), GFP_KERNEL);
		if (!freq_table) {
		ret = -ENOMEM;
		goto out;
		}

		for (i = 0, rate = 0; i < max_opps; i++, rate++) {
		/* find next rate */
		opp = dev_pm_opp_find_freq_ceil(dev, &rate);
		if (IS_ERR(opp)) {
		ret = PTR_ERR(opp);
		goto out;
		}
		freq_table[i].driver_data = i;
		freq_table[i].frequency = rate / 1000;
		}

		freq_table[i].driver_data = i;
		freq_table[i].frequency = CPUFREQ_TABLE_END;

		*table = &freq_table[0];

		out:
		rcu_read_unlock();
		if (ret)
		kfree(freq_table);

		return ret;
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);

		/**
		* dev_pm_opp_free_cpufreq_table() - free the cpufreq table
		* @dev: device for which we do this operation
		* @table: table to free
		*
		* Free up the table allocated by dev_pm_opp_init_cpufreq_table
		*/
		void dev_pm_opp_free_cpufreq_table(struct device *dev,
		struct cpufreq_frequency_table **table)
		{
		if (!table)
		return;

		kfree(*table);
		*table = NULL;
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);