Skip to contentSkip to conversation

power: introduce library for device-specific OPPs

PATCH Superseded Nishanth Menon 4 participants 9 messages Sep 22, 2010 – Sep 23, 2010

Subsystems (4)

v3 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/1 power: introduce library for device-specific OPPs

SOCs have a standard set of tuples consisting of frequency and voltage pairs that the device will support per voltage domain. These are called Operating Performance Points or OPPs. The actual definitions of OPP varies over silicon versions. For a specific domain, we can have a set of {frequency, voltage} pairs. As the kernel boots and more information is available, a default set of these are activated based on the precise nature of device. Further on operation, based on conditions prevailing in the system (such as temperature), some OPP availability may be temporarily controlled by the SoC frameworks.

To implement an OPP, some sort of power management support is necessary hence this library depends on CONFIG_PM.

Contributions include:
Sanjeev Premi for the initial concept:

	http://patchwork.kernel.org/patch/50998/

Kevin Hilman for converting original design to device-based Kevin Hilman and Paul Walmsey for cleaning up many of the function abstractions, improvements and data structure handling Romit Dasgupta for using enums instead of opp pointers Thara Gopinath, Eduardo Valentin and Vishwanath BS for fixes and cleanups.
Linus Walleij for recommending this layer be made generic for usage in other architectures beyond OMAP and ARM.
Mark Brown, Andrew Morton, Rafael J Wysocki for valuable improvements.

Discussions and comments from:
http://marc.info/?l=linux-omap&m=126033945313269&w=2
http://marc.info/?l=linux-omap&m=125482970102327&w=2
http://marc.info/?t=125809247500002&r=1&w=2
http://marc.info/?l=linux-omap&m=126025973426007&w=2
http://marc.info/?t=128152609200064&r=1&w=2
http://marc.info/?t=128468723000002&r=1&w=2
incorporated.

Cc Benoit Cousson <[email protected]>
Cc Madhusudhan Chikkature Rajashekar <[email protected]>
Cc Phil Carmody <[email protected]>
Cc Roberto Granados Dorado <[email protected]>
Cc Santosh Shilimkar <[email protected]>
Cc Sergio Alberto Aguirre Rodriguez <[email protected]>
Cc Tero Kristo <[email protected]>
Cc Eduardo Valentin <[email protected]>
Cc Paul Walmsley <[email protected]>
Cc Sanjeev Premi <[email protected]>
Cc Thara Gopinath <[email protected]>
Cc Vishwanath BS <[email protected]>
Cc Linus Walleij <[email protected]>
Cc Mark Brown <[email protected]>
Cc Andrew Morton <[email protected]>
Cc Rafael J. Wysocki <[email protected]>

---
V3:
Bunch of documentation update based on feedback removed opp_def - opp_add enables the opp by default lock usage optimization

Sample usage:
http://pastebin.mozilla.org/794786 -> cleanups for OMAP power
http://pastebin.mozilla.org/794787 -> Sample OPP initialization for OMAP

V2:
https://patchwork.kernel.org/patch/189532/
Incorporated review comments from v1. major changes being:
$subject change to reflect this is for power. Documentation revamp and including it in the patch :) OPP_DEF removed - lets introduce this if needed or leave it to SOC frameworks to organize code as needed.
Rename of enable to available to better reflect the intent few fixes and typos
Introduced mutex based locking for controlling access to list modification (note: query functions are still unsafe- rationale
in the patch below)
A new home for opp.c in drivers/base/power (moved from lib/) A few optimization in function flow and additional error checks added to exposed functions
offline aligned with Kevin for cleaning up the copyrights

V1:

	http://marc.info/?t=128468723000002&r=1&w=2
 Documentation/power/00-INDEX |    2 +
 Documentation/power/opp.txt  |  330 ++++++++++++++++++++++++++
 drivers/base/power/Makefile  |    1 +
 drivers/base/power/opp.c     |  534 ++++++++++++++++++++++++++++++++++++++++++
 include/linux/opp.h          |  103 ++++++++
 kernel/power/Kconfig         |   14 ++
 6 files changed, 984 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/power/opp.txt
 create mode 100644 drivers/base/power/opp.c
 create mode 100644 include/linux/opp.h
Documentation/power/00-INDEX +2 -0
index fb742c2..45e9d4a 100644
@@ -14,6 +14,8 @@ interface.txt
 	- Power management user interface in /sys/power
 notifiers.txt
 	- Registering suspend notifiers in device drivers
+opp.txt
+	- Operating Performance Point library
 pci.txt
 	- How the PCI Subsystem Does Power Management
 pm_qos_interface.txt
Documentation/power/opp.txt new file +330 -0

330 lines not on this page · raw message

drivers/base/power/Makefile +1 -0
index cbccf9a..abe46ed 100644
@@ -3,6 +3,7 @@ obj-$(CONFIG_PM_SLEEP)	+= main.o wakeup.o
 obj-$(CONFIG_PM_RUNTIME)	+= runtime.o
 obj-$(CONFIG_PM_OPS)	+= generic_ops.o
 obj-$(CONFIG_PM_TRACE_RTC)	+= trace.o
+obj-$(CONFIG_PM_OPP)	+= opp.o
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
 ccflags-$(CONFIG_PM_VERBOSE)   += -DDEBUG
drivers/base/power/opp.c new file +534 -0

534 lines not on this page · raw message

include/linux/opp.h new file +103 -0

103 lines not on this page · raw message

kernel/power/Kconfig +14 -0
index ca6066a..634eab6 100644
@@ -242,3 +242,17 @@ config PM_OPS
 	bool
 	depends on PM_SLEEP || PM_RUNTIME
 	default y
+
+config PM_OPP
+	bool "Enable Operating Performance Point(OPP) Layer library"
+	depends on PM
+	---help---
+	  SOCs have a standard set of tuples consisting of frequency and
+	  voltage pairs that the device will support per voltage domain. This
+	  is called Operating Performance Point or OPP. The actual definitions
+	  of OPP varies over silicon within the same family of devices.
+
+	  OPP layer organizes the data internally using device pointers
+	  representing individual voltage domains and provides SOC
+	  implementations a ready to use framework to manage OPPs.
+	  For more information, read <file:Documentation/power/opp.txt>
Signature · 1 line
1.6.3.3
#1 lore raw

[Trimming the CC list slightly.]

Hi,

Quoted 12 lines · Nishanth Menon

SOCs have a standard set of tuples consisting of frequency and voltage pairs that the device will support per voltage domain. These are called Operating Performance Points or OPPs. The actual definitions of OPP varies over silicon versions. For a specific domain, we can have a set of {frequency, voltage} pairs. As the kernel boots and more information is available, a default set of these are activated based on the precise nature of device. Further on operation, based on conditions prevailing in the system (such as temperature), some OPP availability may be temporarily controlled by the SoC frameworks.

To implement an OPP, some sort of power management support is necessary hence this library depends on CONFIG_PM.

...

Quoted 4 lines

---

...

First, thanks for addressing the previous comments, things look much better now. In particular the documentation has been improved a lot in my view.

Quoted 94 lines
 Documentation/power/00-INDEX |    2 +
 Documentation/power/opp.txt  |  330 ++++++++++++++++++++++++++
 drivers/base/power/Makefile  |    1 +
 drivers/base/power/opp.c     |  534 ++++++++++++++++++++++++++++++++++++++++++
 include/linux/opp.h          |  103 ++++++++
 kernel/power/Kconfig         |   14 ++
 6 files changed, 984 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/power/opp.txt
 create mode 100644 drivers/base/power/opp.c
 create mode 100644 include/linux/opp.h
Documentation/power/00-INDEX +2 -0
index fb742c2..45e9d4a 100644
@@ -14,6 +14,8 @@ interface.txt
 	- Power management user interface in /sys/power
 notifiers.txt
 	- Registering suspend notifiers in device drivers
+opp.txt
+	- Operating Performance Point library
 pci.txt
 	- How the PCI Subsystem Does Power Management
 pm_qos_interface.txt
Documentation/power/opp.txt new file +64 -0
new file mode 100644
index 0000000..7e41e33
@@ -0,0 +1,330 @@
+*=============*
+* OPP Library *
+*=============*
+
+Contents
+--------
+1. Introduction
+2. Initial OPP List Registration
+3. OPP Search Functions
+4. OPP Availability Control Functions
+5. OPP Data Retrieval Functions
+6. Cpufreq Table Generation
+7. Data Structures
+
+1. Introduction
+===============
+Complex SOCs of today consists of a multiple sub-modules working in conjunction.
+In an operational system executing varied use cases, not all modules in the SoC
+need to function at their highest performing frequency all the time. To
+facilitate this, sub-modules in a SoC are grouped into domains, allowing some
+domains to run at lower voltage and frequency while other domains are loaded
+more. The set of discrete tuples consisting of frequency and voltage pairs that
+the device will support per domain are called Operating Performance Points or
+OPPs.
+
+OPP library provides a set of helper functions to organize and query the OPP
+information. The library is located in drivers/base/power/opp.c and the header
+is located in include/linux/opp.h. OPP library can be enabled by enabling
+CONFIG_PM_OPP from power management menuconfig menu. OPP library depends on
+CONFIG_PM as certain SOCs such as Texas Instrument's OMAP framework allows to
+optionally boot at a certain OPP without needing cpufreq.
+
+Typical usage of the OPP library is as follows:
+(users)		-> registers a set of default OPPs		-> (library)
+SoC framework	-> modifies on required cases certain OPPs	-> OPP layer
+		-> queries to search/retrieve information	->
+
+OPP layer expects each domain to be represented by a unique device pointer. SoC
+framework registers a set of initial OPPs per device with the OPP layer. This
+list is expected to be an optimally small number typically around 5 per device.
+This initial list contains a set of OPPs that the framework expects to be safely
+enabled by default in the system.
+
+Note on OPP Availability:
+------------------------
+As the system proceeds to operate, SoC framework may choose to make certain
+OPPs available or not available on each device based on various external
+factors. Example usage: Thermal management or other exceptional situations where
+SoC framework might choose to disable a higher frequency OPP to safely continue
+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}, opp_get_voltage, opp_get_freq, opp_get_opp_count
+and opp_init_cpufreq_table
+
+opp_find_freq_exact is meant to be used to find the opp pointer which can then
+be used for opp_enable/disable functions to make an opp available as required.
+
+WARNING: Users of OPP library should refresh their availability count using
+get_opp_count if opp_enable/disable functions are invoked for a device, the
+exact mechanism to trigger these or the notification mechanism to other
+dependent subsystems such as cpufreq are left to the discretion of the SoC
+specific framework which uses the OPP library. Similar care needs to be taken

Documentation/power/opp.txt line 74

Quoted 10 lines
Documentation/power/opp.txt new file +10 -0
+care to refresh the cpufreq table in cases of these operations.
+
+WARNING on OPP List Modification Vs Query operations:
+----------------------------------------------------
+The OPP layer's query functions are expected to be used in multiple contexts
+(including calls from interrupt locked context) based on SoC framework
+implementation. Only OPP modification functions are guaranteed exclusivity by
+the OPP library. Exclusivity between query functions and modification functions
+should be handled by the users such as the SoC framework appropriately; else,
+there is a risk for the query functions to retrieve stale data.

Well, this sounds like a good use case for RCU.

...

Quoted 127 lines
drivers/base/power/Makefile +1 -0
index cbccf9a..abe46ed 100644
@@ -3,6 +3,7 @@ obj-$(CONFIG_PM_SLEEP)	+= main.o wakeup.o
 obj-$(CONFIG_PM_RUNTIME)	+= runtime.o
 obj-$(CONFIG_PM_OPS)	+= generic_ops.o
 obj-$(CONFIG_PM_TRACE_RTC)	+= trace.o
+obj-$(CONFIG_PM_OPP)	+= opp.o
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
 ccflags-$(CONFIG_PM_VERBOSE)   += -DDEBUG
drivers/base/power/opp.c new file +109 -0
new file mode 100644
index 0000000..311fd7f
@@ -0,0 +1,534 @@
+/*
+ * Generic OPP Interface
+ *
+ * Copyright (C) 2009-2010 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/kernel.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/cpufreq.h>
+#include <linux/list.h>
+#include <linux/opp.h>
+
+/*
+ * Internal data structure organization with the OPP layer library is as
+ * follows:
+ * dev_opp_list (root)
+ *	|- device 1 (represents voltage domain 1)
+ *	|	|- opp 1 (availability, freq, voltage)
+ *	|	|- opp 2 ..
+ *	...	...
+ *	|	`- opp n ..
+ *	|- device 2 (represents the next voltage domain)
+ *	...
+ *	`- device m (represents mth voltage domain)
+ * device 1, 2.. are represented by dev_opp structure while each opp
+ * is represented by the opp structure.
+ */
+
+/**
+ * struct opp - Generic OPP description structure
+ * @node:	opp list node. The nodes are maintained throughout the lifetime
+ *		of boot. It is expected only an optimal set of OPPs are
+ *		added to the library by the SoC framework.
+ *		IMPORTANT: the opp nodes should be maintained in increasing
+ *		order
+ * @available:	true/false - marks if this OPP as available or not
+ * @rate:	Frequency in hertz
+ * @u_volt:	Nominal voltage in microvolts corresponding to this OPP
+ * @dev_opp:	points back to the device_opp struct this opp belongs to
+ *
+ * This structure stores the OPP information for a given device.
+ */
+struct opp {
+	struct list_head node;
+
+	bool available;
+	unsigned long rate;
+	unsigned long u_volt;
+
+	struct device_opp *dev_opp;
+};
+
+/**
+ * struct device_opp - Device opp structure
+ * @node:	list node - contains the devices with OPPs that
+ *		have been registered
+ * @lock:	Lock to allow exclusive modification in the list for the device
+ * @dev:	device pointer
+ * @opp_list:	list of opps
+ * @available_opp_count: how many opps are actually available
+ *
+ * This is an internal data structure maintaining the link to opps attached to
+ * a device. This structure is not meant to be shared to users as it is
+ * meant for book keeping and private to OPP library
+ */
+struct device_opp {
+	struct list_head node;
+	/* mutex for exclusive modification of device OPP list */
+	struct mutex lock;
+
+	struct device *dev;
+
+	struct list_head opp_list;
+	u32 available_opp_count;
+};
+
+/*
+ * The root of the list of all devices. All device_opp structures branch off
+ * from here, with each device_opp containing the list of opp it supports in
+ * various states of availability.
+ */
+static LIST_HEAD(dev_opp_list);
+/* Lock to allow exclusive modification to the device list */
+static DEFINE_MUTEX(dev_opp_list_lock);
+
+/**
+ * find_device_opp() - find device_opp struct using device pointer
+ * @dev:	device pointer used to lookup device OPPs
+ *
+ * Search list of device OPPs for one containing matching device.
+ *
+ * Returns pointer to 'struct device_opp' if found, otherwise -ENODEV or
+ * -EINVAL based on type of error.
+ */
+static struct device_opp *find_device_opp(struct device *dev)
+{
+	struct device_opp *tmp_dev_opp, *dev_opp = ERR_PTR(-ENODEV);
+
+	if (unlikely(!dev || IS_ERR(dev))) {

drivers/base/power/opp.c line 119

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		pr_err("%s: Invalid parameters being passed\n", __func__);
+		return ERR_PTR(-EINVAL);
+	}
+
+	list_for_each_entry(tmp_dev_opp, &dev_opp_list, node) {
+		if (tmp_dev_opp->dev == dev) {
+			dev_opp = tmp_dev_opp;
+			break;
+		}
+	}

As I said, it seems you can use RCU read locking around the list traversal to protect it from concurrent modification.

Quoted 3 lines
drivers/base/power/opp.c new file +3 -0
+	return dev_opp;
+}
+

...

Quoted 29 lines
drivers/base/power/opp.c new file +29 -0
+/**
+ * opp_find_freq_exact() - search for an exact frequency
+ * @dev:		device for which we do this operation
+ * @freq:		frequency to search for
+ * @is_available:	true/false - match for available opp
+ *
+ * Searches for exact match in the opp list and returns pointer to the matching
+ * opp if found, else returns ERR_PTR in case of error and should be handled
+ * using IS_ERR.
+ *
+ * Note: available is a modifier for the search. if available=true, then the
+ * match is for exact matching frequency and is available in the stored OPP
+ * table. if false, the match is for exact frequency which is not available.
+ *
+ * This provides a mechanism to enable an opp which is not available currently
+ * or the opposite as well.
+ *
+ * WARNING: using this api simultaneously with opp_add/enable/disable may
+ * result in stale data. To ensure sanity of results, callers must ensure
+ * exclusivity from mentioned functions in some form.
+ */
+struct opp *opp_find_freq_exact(struct device *dev,
+				     unsigned long freq, bool available)
+{
+	struct device_opp *dev_opp;
+	struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+	dev_opp = find_device_opp(dev);
+	if (IS_ERR(dev_opp))

drivers/base/power/opp.c line 226

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		return opp;
+
+	list_for_each_entry(temp_opp, &dev_opp->opp_list, node) {
+		if (temp_opp->available == available &&
+				temp_opp->rate == freq) {
+			opp = temp_opp;
+			break;
+		}
+	}
+

Same here.

Quoted 19 lines
drivers/base/power/opp.c new file +19 -0
+	return opp;
+}
+
+/**
+ * opp_find_freq_ceil() - Search for an rounded ceil freq
+ * @dev:	device for which we do this operation
+ * @freq:	Start frequency
+ *
+ * Search for the matching ceil *available* OPP from a starting freq
+ * for a device.
+ *
+ * Returns matching *opp and refreshes *freq accordingly, else returns
+ * ERR_PTR in case of error and should be handled using IS_ERR.
+ *
+ * Example usages:
+ *	* find match/next highest available frequency *
+ *	freq = 350000;
+ *	opp = opp_find_freq_ceil(dev, &freq))
+ *	if (IS_ERR(opp))

drivers/base/power/opp.c line 255

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+ *		pr_err("unable to find a higher frequency\n");
+ *	else
+ *		pr_info("match freq = %ld\n", freq);
+ *
+ *	* print all supported frequencies in ascending order *
+ *	freq = 0; * Search for the lowest available frequency *
+ *	while (!IS_ERR(opp = opp_find_freq_ceil(OPP_MPU, &freq)) {
+ *		pr_info("freq = %ld\n", freq);
+ *		freq++; * for next higher match *
+ *	}

I think it's sufficient to put the examples into the doc (the ones below too).

Quoted 15 lines

+ * WARNING: using this api simultaneously with opp_add/enable/disable may
+ * result in stale data. To ensure sanity of results, callers must ensure
+ * exclusivity from mentioned functions in some form.
+ */

drivers/base/power/opp.c new file +11 -0
+struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
+{
+	struct device_opp *dev_opp;
+	struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+	if (!dev || !freq) {
+		pr_err("%s: invalid param dev=%p freq=%p\n", __func__,
+				dev, freq);
+		return ERR_PTR(-EINVAL);
+	}
+	dev_opp = find_device_opp(dev);

drivers/base/power/opp.c line 281

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	if (IS_ERR(dev_opp))
+		return opp;
+
+	list_for_each_entry(temp_opp, &dev_opp->opp_list, node) {
+		if (temp_opp->available && temp_opp->rate >= *freq) {
+			opp = temp_opp;
+			*freq = opp->rate;
+			break;
+		}
+	}

This also may use read-side RCU to protect the list from concurrent modification IMO.

Quoted 11 lines
drivers/base/power/opp.c new file +11 -0
+	return opp;
+}
+
+/**
+ * opp_find_freq_floor() - Search for a rounded floor freq
+ * @dev:	device for which we do this operation
+ * @freq:	Start frequency
+ *
+ * Search for the matching floor *available* OPP from a starting freq
+ * for a device.
+ *

...

Quoted 12 lines

+ */

drivers/base/power/opp.c new file +11 -0
+struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
+{
+	struct device_opp *dev_opp;
+	struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+	if (!dev || !freq) {
+		pr_err("%s: invalid param dev=%p freq=%p\n", __func__,
+				dev, freq);
+		return ERR_PTR(-EINVAL);
+	}
+	dev_opp = find_device_opp(dev);

drivers/base/power/opp.c line 341

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	if (IS_ERR(dev_opp))
+		return opp;
+
+	list_for_each_entry_reverse(temp_opp, &dev_opp->opp_list, node) {
+		if (temp_opp->available && temp_opp->rate <= *freq) {
+			opp = temp_opp;
+			*freq = opp->rate;
+			break;
+		}
+	}

Same here.

Quoted 18 lines
drivers/base/power/opp.c new file +18 -0
+	return opp;
+}
+
+/**
+ * opp_add()  - Add an OPP table from a table definitions
+ * @dev:	device for which we do this operation
+ * @freq:	Frequency in Hz for this OPP
+ * @u_volt:	Voltage in uVolts for this OPP
+ *
+ * This function adds an opp definition to the opp list and returns status.
+ * The opp is made available by default and it can be controlled using
+ * opp_enable/disable functions.
+ *
+ * WARNING: This function should not be used in interrupt context.
+ */
+int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
+{
+	struct device_opp *tmp_dev_opp, *dev_opp = NULL;

drivers/base/power/opp.c line 370

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	struct opp *opp, *new_opp;
+	struct list_head *head;
+
+	/* Check for existing list for 'dev' */
+	list_for_each_entry(tmp_dev_opp, &dev_opp_list, node) {
+		if (dev == tmp_dev_opp->dev) {
+			dev_opp = tmp_dev_opp;
+			break;
+		}
+	}

You need to ensure that the list won't change while you're traversing it here. In fact, it should not change until the changes you're going to make are complete, unless you can guarantee that no one will remove the dev_opp you've just found (perhaps you can).

I think it would be sufficient to use a single spinlock to protect the entire data structure from concurrent modification if memory allocations were made upfront.

Quoted 34 lines
drivers/base/power/opp.c new file +34 -0
+	/* allocate new OPP node */
+	new_opp = kzalloc(sizeof(struct opp), GFP_KERNEL);
+	if (!new_opp) {
+		pr_warning("%s: unable to allocate new opp node\n",
+			__func__);
+		return -ENOMEM;
+	}
+
+	if (!dev_opp) {
+		/* Allocate a new device OPP table */
+		dev_opp = kzalloc(sizeof(struct device_opp), GFP_KERNEL);
+		if (!dev_opp) {
+			kfree(new_opp);
+			pr_warning("%s: unable to allocate device structure\n",
+				__func__);
+			return -ENOMEM;
+		}
+
+		dev_opp->dev = dev;
+		INIT_LIST_HEAD(&dev_opp->opp_list);
+		mutex_init(&dev_opp->lock);
+
+		/* Secure the device list modification */
+		mutex_lock(&dev_opp_list_lock);
+		list_add(&dev_opp->node, &dev_opp_list);
+		mutex_unlock(&dev_opp_list_lock);
+	}
+
+	/* populate the opp table */
+	new_opp->rate = freq;
+	new_opp->u_volt = u_volt;
+	new_opp->available = true;
+
+	/* make the dev_opp modification safe */

drivers/base/power/opp.c line 415

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	mutex_lock(&dev_opp->lock);
+	/* Insert new OPP in order of increasing frequency */
+	head = &dev_opp->opp_list;
+	list_for_each_entry_reverse(opp, &dev_opp->opp_list, node) {
+		if (new_opp->rate >= opp->rate) {
+			head = &opp->node;
+			break;
+		}
+	}
+	list_add(&new_opp->node, head);

It seems you should check if the OPP is still there, shouldn't you?

Quoted 21 lines
drivers/base/power/opp.c new file +21 -0
+	if (new_opp->available)
+		dev_opp->available_opp_count++;
+	mutex_unlock(&dev_opp->lock);
+
+	return 0;
+}
+
+/**
+ * opp_enable() - Enable a specific OPP
+ * @opp:	Pointer to opp
+ *
+ * Enables a provided opp. If the operation is valid, this returns 0, else the
+ * corresponding error value. It is meant to be used for users an OPP available
+ * after being temporarily made unavailable with opp_disable.
+ *
+ * OPP used here is from the opp_find_freq_* or other search functions
+ * WARNING: This function should not be used in interrupt context.
+ */
+int opp_enable(struct opp *opp)
+{
+	if (unlikely(!opp || IS_ERR(opp))) {

drivers/base/power/opp.c line 446

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		pr_err("%s: Invalid parameters being passed\n", __func__);
+		return -EINVAL;
+	}
+
+	mutex_lock(&opp->dev_opp->lock);
+	if (!opp->available && opp->dev_opp)
+		opp->dev_opp->available_opp_count++;
+
+	opp->available = true;
+	mutex_unlock(&opp->dev_opp->lock);

If these operations don't occur too often, you can use a single lock for all write-side operations. That would simplify things quite a bit.

Quoted 3 lines
drivers/base/power/opp.c new file +3 -0
+	return 0;
+}
+

...

Quoted 19 lines
drivers/base/power/opp.c new file +19 -0
+void opp_init_cpufreq_table(struct device *dev,
+			    struct cpufreq_frequency_table **table)
+{
+	struct device_opp *dev_opp;
+	struct opp *opp;
+	struct cpufreq_frequency_table *freq_table;
+	int i = 0;
+
+	dev_opp = find_device_opp(dev);
+	if (IS_ERR(dev_opp)) {
+		pr_warning("%s: unable to find device\n", __func__);
+		return;
+	}
+
+	freq_table = kzalloc(sizeof(struct cpufreq_frequency_table) *
+			     (dev_opp->available_opp_count + 1), GFP_ATOMIC);
+	if (!freq_table) {
+		pr_warning("%s: failed to allocate frequency table\n",
+			   __func__);

drivers/base/power/opp.c line 527

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		return;
+	}
+
+	list_for_each_entry(opp, &dev_opp->opp_list, node) {
+		if (opp->available) {
+			freq_table[i].index = i;
+			freq_table[i].frequency = opp->rate / 1000;
+			i++;
+		}
+	}

That also may use read-side RCU for protection from concurrent modification.

drivers/base/power/opp.c line 534

Quoted 6 lines
drivers/base/power/opp.c new file +6 -0
+	freq_table[i].index = i;
+	freq_table[i].frequency = CPUFREQ_TABLE_END;
+
+	*table = &freq_table[0];
+}
+#endif		/* CONFIG_CPU_FREQ */

The rest looks fine to me.

Thanks,
Rafael

#2 lore raw

Rafael J. Wysocki had written, on 09/22/2010 07:03 PM, the following:

Quoted 1 line

[Trimming the CC list slightly.]

[...]

Quoted 4 lines

...

First, thanks for addressing the previous comments, things look much better now. In particular the documentation has been improved a lot in my view.

Thanks for the excellent reviews :)

[...]

Quoted 11 lines

Documentation/power/opp.txt line 74

Quoted 9 lines
Documentation/power/opp.txt new file +9 -0
+
+WARNING on OPP List Modification Vs Query operations:
+----------------------------------------------------
+The OPP layer's query functions are expected to be used in multiple contexts
+(including calls from interrupt locked context) based on SoC framework
+implementation. Only OPP modification functions are guaranteed exclusivity by
+the OPP library. Exclusivity between query functions and modification functions
+should be handled by the users such as the SoC framework appropriately; else,
+there is a risk for the query functions to retrieve stale data.

Well, this sounds like a good use case for RCU.

Kevin did point out rwlock but am I confusing with
http://lwn.net/Articles/364583/
If I get the message right, rwlock is more or less on it's way out?

[...]

Quoted 22 lines
Quoted 5 lines
drivers/base/power/opp.c new file +5 -0
+static struct device_opp *find_device_opp(struct device *dev)
+{
+     struct device_opp *tmp_dev_opp, *dev_opp = ERR_PTR(-ENODEV);
+
+     if (unlikely(!dev || IS_ERR(dev))) {

drivers/base/power/opp.c line 119

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+             pr_err("%s: Invalid parameters being passed\n", __func__);
+             return ERR_PTR(-EINVAL);
+     }
+
+     list_for_each_entry(tmp_dev_opp, &dev_opp_list, node) {
+             if (tmp_dev_opp->dev == dev) {
+                     dev_opp = tmp_dev_opp;
+                     break;
+             }
+     }

As I said, it seems you can use RCU read locking around the list traversal to protect it from concurrent modification.

Quoted 3 lines
drivers/base/power/opp.c new file +3 -0
+     return dev_opp;
+}
+

[...]

Quoted 44 lines
Quoted 8 lines
drivers/base/power/opp.c new file +8 -0
+struct opp *opp_find_freq_exact(struct device *dev,
+                                  unsigned long freq, bool available)
+{
+     struct device_opp *dev_opp;
+     struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+     dev_opp = find_device_opp(dev);
+     if (IS_ERR(dev_opp))

drivers/base/power/opp.c line 226

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+             return opp;
+
+     list_for_each_entry(temp_opp, &dev_opp->opp_list, node) {
+             if (temp_opp->available == available &&
+                             temp_opp->rate == freq) {
+                     opp = temp_opp;
+                     break;
+             }
+     }
+

Same here.

Quoted 23 lines
drivers/base/power/opp.c new file +23 -0
+     return opp;
+}
+
+/**
+ * opp_find_freq_ceil() - Search for an rounded ceil freq
+ * @dev:     device for which we do this operation
+ * @freq:    Start frequency
+ *
+ * Search for the matching ceil *available* OPP from a starting freq
+ * for a device.
+ *
+ * Returns matching *opp and refreshes *freq accordingly, else returns
+ * ERR_PTR in case of error and should be handled using IS_ERR.
+ *
+ * Example usages:
+ *   * find match/next highest available frequency *
+ *   freq = 350000;
+ *   opp = opp_find_freq_ceil(dev, &freq))
+ *   if (IS_ERR(opp))
+ *           pr_err("unable to find a higher frequency\n");
+ *   else
+ *           pr_info("match freq = %ld\n", freq);
+ *
Quoted 9 lines
Quoted 6 lines
+ *   * print all supported frequencies in ascending order *
+ *   freq = 0; * Search for the lowest available frequency *
+ *   while (!IS_ERR(opp = opp_find_freq_ceil(OPP_MPU, &freq)) {

+ * pr_info("freq = %ld\n", freq);
+ * freq++; * for next higher match *
+ * }

I think it's sufficient to put the examples into the doc (the ones below too).

Ack. thanks for pointing it out.. will fix in v4.

Quoted 8 lines

drivers/base/power/opp.c line 534

Quoted 6 lines
drivers/base/power/opp.c new file +6 -0
+     freq_table[i].index = i;
+     freq_table[i].frequency = CPUFREQ_TABLE_END;
+
+     *table = &freq_table[0];
+}
+#endif               /* CONFIG_CPU_FREQ */

The rest looks fine to me.

thx.

Signature · 2 lines
Regards,
Nishanth Menon
#3 lore raw
Quoted 23 lines · Nishanth Menon

Rafael J. Wysocki had written, on 09/22/2010 07:03 PM, the following:

Quoted 1 line

[Trimming the CC list slightly.]

[...]

Quoted 4 lines

...

First, thanks for addressing the previous comments, things look much better now. In particular the documentation has been improved a lot in my view.

Thanks for the excellent reviews :)

[...]

Quoted 11 lines

Documentation/power/opp.txt line 74

Quoted 9 lines
Documentation/power/opp.txt new file +9 -0
+
+WARNING on OPP List Modification Vs Query operations:
+----------------------------------------------------
+The OPP layer's query functions are expected to be used in multiple contexts
+(including calls from interrupt locked context) based on SoC framework
+implementation. Only OPP modification functions are guaranteed exclusivity by
+the OPP library. Exclusivity between query functions and modification functions
+should be handled by the users such as the SoC framework appropriately; else,
+there is a risk for the query functions to retrieve stale data.

Well, this sounds like a good use case for RCU.

Quoted 3 lines

Kevin did point out rwlock but am I confusing with
http://lwn.net/Articles/364583/
If I get the message right, rwlock is more or less on it's way out?

RCU is different from the reader-writer locks that are on their way out.

Let's think about RCU a little more and see if it might be worth using.

As these APIs are infrequencly accessed, I'm thinking a single spinlock to protect the whole list from concurrent access/modification is sufficient.

Kevin

#4 lore raw
In reply to Nishanth Menon
Quoted 23 lines · Nishanth Menon

Rafael J. Wysocki had written, on 09/22/2010 07:03 PM, the following:

Quoted 1 line

[Trimming the CC list slightly.]

[...]

Quoted 4 lines

...

First, thanks for addressing the previous comments, things look much better now. In particular the documentation has been improved a lot in my view.

Thanks for the excellent reviews :)

[...]

Quoted 11 lines

Documentation/power/opp.txt line 74

Quoted 9 lines
Documentation/power/opp.txt new file +9 -0
+
+WARNING on OPP List Modification Vs Query operations:
+----------------------------------------------------
+The OPP layer's query functions are expected to be used in multiple contexts
+(including calls from interrupt locked context) based on SoC framework
+implementation. Only OPP modification functions are guaranteed exclusivity by
+the OPP library. Exclusivity between query functions and modification functions
+should be handled by the users such as the SoC framework appropriately; else,
+there is a risk for the query functions to retrieve stale data.

Well, this sounds like a good use case for RCU.

Quoted 3 lines

Kevin did point out rwlock but am I confusing with
http://lwn.net/Articles/364583/
If I get the message right, rwlock is more or less on it's way out?

RCU is different from the reader-writer locks that are on their way out.

Let's think about RCU a little more and see if it might be worth using.

As these APIs are infrequencly accessed, I'm thinking a single spinlock to protect the whole list from concurrent access/modification is sufficient.

Kevin

#5 lore raw
In reply to Rafael J. Wysocki

Rafael J. Wysocki had written, on 09/22/2010 07:03 PM, the following:

Quoted 1 line

[Trimming the CC list slightly.]

[...]

Quoted 4 lines

...

First, thanks for addressing the previous comments, things look much better now. In particular the documentation has been improved a lot in my view.

Thanks for the excellent reviews :)

[...]

Quoted 11 lines

Documentation/power/opp.txt line 74

Quoted 9 lines
Documentation/power/opp.txt new file +9 -0
+
+WARNING on OPP List Modification Vs Query operations:
+----------------------------------------------------
+The OPP layer's query functions are expected to be used in multiple contexts
+(including calls from interrupt locked context) based on SoC framework
+implementation. Only OPP modification functions are guaranteed exclusivity by
+the OPP library. Exclusivity between query functions and modification functions
+should be handled by the users such as the SoC framework appropriately; else,
+there is a risk for the query functions to retrieve stale data.

Well, this sounds like a good use case for RCU.

Kevin did point out rwlock but am I confusing with
http://lwn.net/Articles/364583/
If I get the message right, rwlock is more or less on it's way out?

[...]

Quoted 22 lines
Quoted 5 lines
drivers/base/power/opp.c new file +5 -0
+static struct device_opp *find_device_opp(struct device *dev)
+{
+     struct device_opp *tmp_dev_opp, *dev_opp = ERR_PTR(-ENODEV);
+
+     if (unlikely(!dev || IS_ERR(dev))) {

drivers/base/power/opp.c line 119

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+             pr_err("%s: Invalid parameters being passed\n", __func__);
+             return ERR_PTR(-EINVAL);
+     }
+
+     list_for_each_entry(tmp_dev_opp, &dev_opp_list, node) {
+             if (tmp_dev_opp->dev == dev) {
+                     dev_opp = tmp_dev_opp;
+                     break;
+             }
+     }

As I said, it seems you can use RCU read locking around the list traversal to protect it from concurrent modification.

Quoted 3 lines
drivers/base/power/opp.c new file +3 -0
+     return dev_opp;
+}
+

[...]

Quoted 44 lines
Quoted 8 lines
drivers/base/power/opp.c new file +8 -0
+struct opp *opp_find_freq_exact(struct device *dev,
+                                  unsigned long freq, bool available)
+{
+     struct device_opp *dev_opp;
+     struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+     dev_opp = find_device_opp(dev);
+     if (IS_ERR(dev_opp))

drivers/base/power/opp.c line 226

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+             return opp;
+
+     list_for_each_entry(temp_opp, &dev_opp->opp_list, node) {
+             if (temp_opp->available == available &&
+                             temp_opp->rate == freq) {
+                     opp = temp_opp;
+                     break;
+             }
+     }
+

Same here.

Quoted 23 lines
drivers/base/power/opp.c new file +23 -0
+     return opp;
+}
+
+/**
+ * opp_find_freq_ceil() - Search for an rounded ceil freq
+ * @dev:     device for which we do this operation
+ * @freq:    Start frequency
+ *
+ * Search for the matching ceil *available* OPP from a starting freq
+ * for a device.
+ *
+ * Returns matching *opp and refreshes *freq accordingly, else returns
+ * ERR_PTR in case of error and should be handled using IS_ERR.
+ *
+ * Example usages:
+ *   * find match/next highest available frequency *
+ *   freq = 350000;
+ *   opp = opp_find_freq_ceil(dev, &freq))
+ *   if (IS_ERR(opp))
+ *           pr_err("unable to find a higher frequency\n");
+ *   else
+ *           pr_info("match freq = %ld\n", freq);
+ *
Quoted 9 lines
Quoted 6 lines
+ *   * print all supported frequencies in ascending order *
+ *   freq = 0; * Search for the lowest available frequency *
+ *   while (!IS_ERR(opp = opp_find_freq_ceil(OPP_MPU, &freq)) {

+ * pr_info("freq = %ld\n", freq);
+ * freq++; * for next higher match *
+ * }

I think it's sufficient to put the examples into the doc (the ones below too).

Ack. thanks for pointing it out.. will fix in v4.

Quoted 8 lines

drivers/base/power/opp.c line 534

Quoted 6 lines
drivers/base/power/opp.c new file +6 -0
+     freq_table[i].index = i;
+     freq_table[i].frequency = CPUFREQ_TABLE_END;
+
+     *table = &freq_table[0];
+}
+#endif               /* CONFIG_CPU_FREQ */

The rest looks fine to me.

thx.

Signature · 2 lines
Regards,
Nishanth Menon
#6 lore raw
In reply to Nishanth Menon

[Trimming the CC list slightly.]

Hi,

Quoted 12 lines · Nishanth Menon

SOCs have a standard set of tuples consisting of frequency and voltage pairs that the device will support per voltage domain. These are called Operating Performance Points or OPPs. The actual definitions of OPP varies over silicon versions. For a specific domain, we can have a set of {frequency, voltage} pairs. As the kernel boots and more information is available, a default set of these are activated based on the precise nature of device. Further on operation, based on conditions prevailing in the system (such as temperature), some OPP availability may be temporarily controlled by the SoC frameworks.

To implement an OPP, some sort of power management support is necessary hence this library depends on CONFIG_PM.

...

Quoted 4 lines

---

...

First, thanks for addressing the previous comments, things look much better now. In particular the documentation has been improved a lot in my view.

Quoted 94 lines
 Documentation/power/00-INDEX |    2 +
 Documentation/power/opp.txt  |  330 ++++++++++++++++++++++++++
 drivers/base/power/Makefile  |    1 +
 drivers/base/power/opp.c     |  534 ++++++++++++++++++++++++++++++++++++++++++
 include/linux/opp.h          |  103 ++++++++
 kernel/power/Kconfig         |   14 ++
 6 files changed, 984 insertions(+), 0 deletions(-)
 create mode 100644 Documentation/power/opp.txt
 create mode 100644 drivers/base/power/opp.c
 create mode 100644 include/linux/opp.h
Documentation/power/00-INDEX +2 -0
index fb742c2..45e9d4a 100644
@@ -14,6 +14,8 @@ interface.txt
 	- Power management user interface in /sys/power
 notifiers.txt
 	- Registering suspend notifiers in device drivers
+opp.txt
+	- Operating Performance Point library
 pci.txt
 	- How the PCI Subsystem Does Power Management
 pm_qos_interface.txt
Documentation/power/opp.txt new file +64 -0
new file mode 100644
index 0000000..7e41e33
@@ -0,0 +1,330 @@
+*=============*
+* OPP Library *
+*=============*
+
+Contents
+--------
+1. Introduction
+2. Initial OPP List Registration
+3. OPP Search Functions
+4. OPP Availability Control Functions
+5. OPP Data Retrieval Functions
+6. Cpufreq Table Generation
+7. Data Structures
+
+1. Introduction
+===============
+Complex SOCs of today consists of a multiple sub-modules working in conjunction.
+In an operational system executing varied use cases, not all modules in the SoC
+need to function at their highest performing frequency all the time. To
+facilitate this, sub-modules in a SoC are grouped into domains, allowing some
+domains to run at lower voltage and frequency while other domains are loaded
+more. The set of discrete tuples consisting of frequency and voltage pairs that
+the device will support per domain are called Operating Performance Points or
+OPPs.
+
+OPP library provides a set of helper functions to organize and query the OPP
+information. The library is located in drivers/base/power/opp.c and the header
+is located in include/linux/opp.h. OPP library can be enabled by enabling
+CONFIG_PM_OPP from power management menuconfig menu. OPP library depends on
+CONFIG_PM as certain SOCs such as Texas Instrument's OMAP framework allows to
+optionally boot at a certain OPP without needing cpufreq.
+
+Typical usage of the OPP library is as follows:
+(users)		-> registers a set of default OPPs		-> (library)
+SoC framework	-> modifies on required cases certain OPPs	-> OPP layer
+		-> queries to search/retrieve information	->
+
+OPP layer expects each domain to be represented by a unique device pointer. SoC
+framework registers a set of initial OPPs per device with the OPP layer. This
+list is expected to be an optimally small number typically around 5 per device.
+This initial list contains a set of OPPs that the framework expects to be safely
+enabled by default in the system.
+
+Note on OPP Availability:
+------------------------
+As the system proceeds to operate, SoC framework may choose to make certain
+OPPs available or not available on each device based on various external
+factors. Example usage: Thermal management or other exceptional situations where
+SoC framework might choose to disable a higher frequency OPP to safely continue
+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}, opp_get_voltage, opp_get_freq, opp_get_opp_count
+and opp_init_cpufreq_table
+
+opp_find_freq_exact is meant to be used to find the opp pointer which can then
+be used for opp_enable/disable functions to make an opp available as required.
+
+WARNING: Users of OPP library should refresh their availability count using
+get_opp_count if opp_enable/disable functions are invoked for a device, the
+exact mechanism to trigger these or the notification mechanism to other
+dependent subsystems such as cpufreq are left to the discretion of the SoC
+specific framework which uses the OPP library. Similar care needs to be taken

Documentation/power/opp.txt line 74

Quoted 10 lines
Documentation/power/opp.txt new file +10 -0
+care to refresh the cpufreq table in cases of these operations.
+
+WARNING on OPP List Modification Vs Query operations:
+----------------------------------------------------
+The OPP layer's query functions are expected to be used in multiple contexts
+(including calls from interrupt locked context) based on SoC framework
+implementation. Only OPP modification functions are guaranteed exclusivity by
+the OPP library. Exclusivity between query functions and modification functions
+should be handled by the users such as the SoC framework appropriately; else,
+there is a risk for the query functions to retrieve stale data.

Well, this sounds like a good use case for RCU.

...

Quoted 127 lines
drivers/base/power/Makefile +1 -0
index cbccf9a..abe46ed 100644
@@ -3,6 +3,7 @@ obj-$(CONFIG_PM_SLEEP)	+= main.o wakeup.o
 obj-$(CONFIG_PM_RUNTIME)	+= runtime.o
 obj-$(CONFIG_PM_OPS)	+= generic_ops.o
 obj-$(CONFIG_PM_TRACE_RTC)	+= trace.o
+obj-$(CONFIG_PM_OPP)	+= opp.o
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
 ccflags-$(CONFIG_PM_VERBOSE)   += -DDEBUG
drivers/base/power/opp.c new file +109 -0
new file mode 100644
index 0000000..311fd7f
@@ -0,0 +1,534 @@
+/*
+ * Generic OPP Interface
+ *
+ * Copyright (C) 2009-2010 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/kernel.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/cpufreq.h>
+#include <linux/list.h>
+#include <linux/opp.h>
+
+/*
+ * Internal data structure organization with the OPP layer library is as
+ * follows:
+ * dev_opp_list (root)
+ *	|- device 1 (represents voltage domain 1)
+ *	|	|- opp 1 (availability, freq, voltage)
+ *	|	|- opp 2 ..
+ *	...	...
+ *	|	`- opp n ..
+ *	|- device 2 (represents the next voltage domain)
+ *	...
+ *	`- device m (represents mth voltage domain)
+ * device 1, 2.. are represented by dev_opp structure while each opp
+ * is represented by the opp structure.
+ */
+
+/**
+ * struct opp - Generic OPP description structure
+ * @node:	opp list node. The nodes are maintained throughout the lifetime
+ *		of boot. It is expected only an optimal set of OPPs are
+ *		added to the library by the SoC framework.
+ *		IMPORTANT: the opp nodes should be maintained in increasing
+ *		order
+ * @available:	true/false - marks if this OPP as available or not
+ * @rate:	Frequency in hertz
+ * @u_volt:	Nominal voltage in microvolts corresponding to this OPP
+ * @dev_opp:	points back to the device_opp struct this opp belongs to
+ *
+ * This structure stores the OPP information for a given device.
+ */
+struct opp {
+	struct list_head node;
+
+	bool available;
+	unsigned long rate;
+	unsigned long u_volt;
+
+	struct device_opp *dev_opp;
+};
+
+/**
+ * struct device_opp - Device opp structure
+ * @node:	list node - contains the devices with OPPs that
+ *		have been registered
+ * @lock:	Lock to allow exclusive modification in the list for the device
+ * @dev:	device pointer
+ * @opp_list:	list of opps
+ * @available_opp_count: how many opps are actually available
+ *
+ * This is an internal data structure maintaining the link to opps attached to
+ * a device. This structure is not meant to be shared to users as it is
+ * meant for book keeping and private to OPP library
+ */
+struct device_opp {
+	struct list_head node;
+	/* mutex for exclusive modification of device OPP list */
+	struct mutex lock;
+
+	struct device *dev;
+
+	struct list_head opp_list;
+	u32 available_opp_count;
+};
+
+/*
+ * The root of the list of all devices. All device_opp structures branch off
+ * from here, with each device_opp containing the list of opp it supports in
+ * various states of availability.
+ */
+static LIST_HEAD(dev_opp_list);
+/* Lock to allow exclusive modification to the device list */
+static DEFINE_MUTEX(dev_opp_list_lock);
+
+/**
+ * find_device_opp() - find device_opp struct using device pointer
+ * @dev:	device pointer used to lookup device OPPs
+ *
+ * Search list of device OPPs for one containing matching device.
+ *
+ * Returns pointer to 'struct device_opp' if found, otherwise -ENODEV or
+ * -EINVAL based on type of error.
+ */
+static struct device_opp *find_device_opp(struct device *dev)
+{
+	struct device_opp *tmp_dev_opp, *dev_opp = ERR_PTR(-ENODEV);
+
+	if (unlikely(!dev || IS_ERR(dev))) {

drivers/base/power/opp.c line 119

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		pr_err("%s: Invalid parameters being passed\n", __func__);
+		return ERR_PTR(-EINVAL);
+	}
+
+	list_for_each_entry(tmp_dev_opp, &dev_opp_list, node) {
+		if (tmp_dev_opp->dev == dev) {
+			dev_opp = tmp_dev_opp;
+			break;
+		}
+	}

As I said, it seems you can use RCU read locking around the list traversal to protect it from concurrent modification.

Quoted 3 lines
drivers/base/power/opp.c new file +3 -0
+	return dev_opp;
+}
+

...

Quoted 29 lines
drivers/base/power/opp.c new file +29 -0
+/**
+ * opp_find_freq_exact() - search for an exact frequency
+ * @dev:		device for which we do this operation
+ * @freq:		frequency to search for
+ * @is_available:	true/false - match for available opp
+ *
+ * Searches for exact match in the opp list and returns pointer to the matching
+ * opp if found, else returns ERR_PTR in case of error and should be handled
+ * using IS_ERR.
+ *
+ * Note: available is a modifier for the search. if available=true, then the
+ * match is for exact matching frequency and is available in the stored OPP
+ * table. if false, the match is for exact frequency which is not available.
+ *
+ * This provides a mechanism to enable an opp which is not available currently
+ * or the opposite as well.
+ *
+ * WARNING: using this api simultaneously with opp_add/enable/disable may
+ * result in stale data. To ensure sanity of results, callers must ensure
+ * exclusivity from mentioned functions in some form.
+ */
+struct opp *opp_find_freq_exact(struct device *dev,
+				     unsigned long freq, bool available)
+{
+	struct device_opp *dev_opp;
+	struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+	dev_opp = find_device_opp(dev);
+	if (IS_ERR(dev_opp))

drivers/base/power/opp.c line 226

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		return opp;
+
+	list_for_each_entry(temp_opp, &dev_opp->opp_list, node) {
+		if (temp_opp->available == available &&
+				temp_opp->rate == freq) {
+			opp = temp_opp;
+			break;
+		}
+	}
+

Same here.

Quoted 19 lines
drivers/base/power/opp.c new file +19 -0
+	return opp;
+}
+
+/**
+ * opp_find_freq_ceil() - Search for an rounded ceil freq
+ * @dev:	device for which we do this operation
+ * @freq:	Start frequency
+ *
+ * Search for the matching ceil *available* OPP from a starting freq
+ * for a device.
+ *
+ * Returns matching *opp and refreshes *freq accordingly, else returns
+ * ERR_PTR in case of error and should be handled using IS_ERR.
+ *
+ * Example usages:
+ *	* find match/next highest available frequency *
+ *	freq = 350000;
+ *	opp = opp_find_freq_ceil(dev, &freq))
+ *	if (IS_ERR(opp))

drivers/base/power/opp.c line 255

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+ *		pr_err("unable to find a higher frequency\n");
+ *	else
+ *		pr_info("match freq = %ld\n", freq);
+ *
+ *	* print all supported frequencies in ascending order *
+ *	freq = 0; * Search for the lowest available frequency *
+ *	while (!IS_ERR(opp = opp_find_freq_ceil(OPP_MPU, &freq)) {
+ *		pr_info("freq = %ld\n", freq);
+ *		freq++; * for next higher match *
+ *	}

I think it's sufficient to put the examples into the doc (the ones below too).

Quoted 15 lines

+ * WARNING: using this api simultaneously with opp_add/enable/disable may
+ * result in stale data. To ensure sanity of results, callers must ensure
+ * exclusivity from mentioned functions in some form.
+ */

drivers/base/power/opp.c new file +11 -0
+struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
+{
+	struct device_opp *dev_opp;
+	struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+	if (!dev || !freq) {
+		pr_err("%s: invalid param dev=%p freq=%p\n", __func__,
+				dev, freq);
+		return ERR_PTR(-EINVAL);
+	}
+	dev_opp = find_device_opp(dev);

drivers/base/power/opp.c line 281

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	if (IS_ERR(dev_opp))
+		return opp;
+
+	list_for_each_entry(temp_opp, &dev_opp->opp_list, node) {
+		if (temp_opp->available && temp_opp->rate >= *freq) {
+			opp = temp_opp;
+			*freq = opp->rate;
+			break;
+		}
+	}

This also may use read-side RCU to protect the list from concurrent modification IMO.

Quoted 11 lines
drivers/base/power/opp.c new file +11 -0
+	return opp;
+}
+
+/**
+ * opp_find_freq_floor() - Search for a rounded floor freq
+ * @dev:	device for which we do this operation
+ * @freq:	Start frequency
+ *
+ * Search for the matching floor *available* OPP from a starting freq
+ * for a device.
+ *

...

Quoted 12 lines

+ */

drivers/base/power/opp.c new file +11 -0
+struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
+{
+	struct device_opp *dev_opp;
+	struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+	if (!dev || !freq) {
+		pr_err("%s: invalid param dev=%p freq=%p\n", __func__,
+				dev, freq);
+		return ERR_PTR(-EINVAL);
+	}
+	dev_opp = find_device_opp(dev);

drivers/base/power/opp.c line 341

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	if (IS_ERR(dev_opp))
+		return opp;
+
+	list_for_each_entry_reverse(temp_opp, &dev_opp->opp_list, node) {
+		if (temp_opp->available && temp_opp->rate <= *freq) {
+			opp = temp_opp;
+			*freq = opp->rate;
+			break;
+		}
+	}

Same here.

Quoted 18 lines
drivers/base/power/opp.c new file +18 -0
+	return opp;
+}
+
+/**
+ * opp_add()  - Add an OPP table from a table definitions
+ * @dev:	device for which we do this operation
+ * @freq:	Frequency in Hz for this OPP
+ * @u_volt:	Voltage in uVolts for this OPP
+ *
+ * This function adds an opp definition to the opp list and returns status.
+ * The opp is made available by default and it can be controlled using
+ * opp_enable/disable functions.
+ *
+ * WARNING: This function should not be used in interrupt context.
+ */
+int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
+{
+	struct device_opp *tmp_dev_opp, *dev_opp = NULL;

drivers/base/power/opp.c line 370

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	struct opp *opp, *new_opp;
+	struct list_head *head;
+
+	/* Check for existing list for 'dev' */
+	list_for_each_entry(tmp_dev_opp, &dev_opp_list, node) {
+		if (dev == tmp_dev_opp->dev) {
+			dev_opp = tmp_dev_opp;
+			break;
+		}
+	}

You need to ensure that the list won't change while you're traversing it here. In fact, it should not change until the changes you're going to make are complete, unless you can guarantee that no one will remove the dev_opp you've just found (perhaps you can).

I think it would be sufficient to use a single spinlock to protect the entire data structure from concurrent modification if memory allocations were made upfront.

Quoted 34 lines
drivers/base/power/opp.c new file +34 -0
+	/* allocate new OPP node */
+	new_opp = kzalloc(sizeof(struct opp), GFP_KERNEL);
+	if (!new_opp) {
+		pr_warning("%s: unable to allocate new opp node\n",
+			__func__);
+		return -ENOMEM;
+	}
+
+	if (!dev_opp) {
+		/* Allocate a new device OPP table */
+		dev_opp = kzalloc(sizeof(struct device_opp), GFP_KERNEL);
+		if (!dev_opp) {
+			kfree(new_opp);
+			pr_warning("%s: unable to allocate device structure\n",
+				__func__);
+			return -ENOMEM;
+		}
+
+		dev_opp->dev = dev;
+		INIT_LIST_HEAD(&dev_opp->opp_list);
+		mutex_init(&dev_opp->lock);
+
+		/* Secure the device list modification */
+		mutex_lock(&dev_opp_list_lock);
+		list_add(&dev_opp->node, &dev_opp_list);
+		mutex_unlock(&dev_opp_list_lock);
+	}
+
+	/* populate the opp table */
+	new_opp->rate = freq;
+	new_opp->u_volt = u_volt;
+	new_opp->available = true;
+
+	/* make the dev_opp modification safe */

drivers/base/power/opp.c line 415

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+	mutex_lock(&dev_opp->lock);
+	/* Insert new OPP in order of increasing frequency */
+	head = &dev_opp->opp_list;
+	list_for_each_entry_reverse(opp, &dev_opp->opp_list, node) {
+		if (new_opp->rate >= opp->rate) {
+			head = &opp->node;
+			break;
+		}
+	}
+	list_add(&new_opp->node, head);

It seems you should check if the OPP is still there, shouldn't you?

Quoted 21 lines
drivers/base/power/opp.c new file +21 -0
+	if (new_opp->available)
+		dev_opp->available_opp_count++;
+	mutex_unlock(&dev_opp->lock);
+
+	return 0;
+}
+
+/**
+ * opp_enable() - Enable a specific OPP
+ * @opp:	Pointer to opp
+ *
+ * Enables a provided opp. If the operation is valid, this returns 0, else the
+ * corresponding error value. It is meant to be used for users an OPP available
+ * after being temporarily made unavailable with opp_disable.
+ *
+ * OPP used here is from the opp_find_freq_* or other search functions
+ * WARNING: This function should not be used in interrupt context.
+ */
+int opp_enable(struct opp *opp)
+{
+	if (unlikely(!opp || IS_ERR(opp))) {

drivers/base/power/opp.c line 446

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		pr_err("%s: Invalid parameters being passed\n", __func__);
+		return -EINVAL;
+	}
+
+	mutex_lock(&opp->dev_opp->lock);
+	if (!opp->available && opp->dev_opp)
+		opp->dev_opp->available_opp_count++;
+
+	opp->available = true;
+	mutex_unlock(&opp->dev_opp->lock);

If these operations don't occur too often, you can use a single lock for all write-side operations. That would simplify things quite a bit.

Quoted 3 lines
drivers/base/power/opp.c new file +3 -0
+	return 0;
+}
+

...

Quoted 19 lines
drivers/base/power/opp.c new file +19 -0
+void opp_init_cpufreq_table(struct device *dev,
+			    struct cpufreq_frequency_table **table)
+{
+	struct device_opp *dev_opp;
+	struct opp *opp;
+	struct cpufreq_frequency_table *freq_table;
+	int i = 0;
+
+	dev_opp = find_device_opp(dev);
+	if (IS_ERR(dev_opp)) {
+		pr_warning("%s: unable to find device\n", __func__);
+		return;
+	}
+
+	freq_table = kzalloc(sizeof(struct cpufreq_frequency_table) *
+			     (dev_opp->available_opp_count + 1), GFP_ATOMIC);
+	if (!freq_table) {
+		pr_warning("%s: failed to allocate frequency table\n",
+			   __func__);

drivers/base/power/opp.c line 527

Quoted 10 lines
drivers/base/power/opp.c new file +10 -0
+		return;
+	}
+
+	list_for_each_entry(opp, &dev_opp->opp_list, node) {
+		if (opp->available) {
+			freq_table[i].index = i;
+			freq_table[i].frequency = opp->rate / 1000;
+			i++;
+		}
+	}

That also may use read-side RCU for protection from concurrent modification.

drivers/base/power/opp.c line 534

Quoted 6 lines
drivers/base/power/opp.c new file +6 -0
+	freq_table[i].index = i;
+	freq_table[i].frequency = CPUFREQ_TABLE_END;
+
+	*table = &freq_table[0];
+}
+#endif		/* CONFIG_CPU_FREQ */

The rest looks fine to me.

Thanks,
Rafael