2016-05-05 04:50:33 -06:00
|
|
|
/*
|
|
|
|
* Generic OPP OF helpers
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/device.h>
|
2017-10-12 04:32:23 -06:00
|
|
|
#include <linux/of_device.h>
|
2016-11-18 03:17:46 -07:00
|
|
|
#include <linux/pm_domain.h>
|
2016-12-01 03:58:19 -07:00
|
|
|
#include <linux/slab.h>
|
2016-05-05 04:50:33 -06:00
|
|
|
#include <linux/export.h>
|
|
|
|
|
|
|
|
#include "opp.h"
|
|
|
|
|
2018-06-14 00:34:43 -06:00
|
|
|
/*
|
|
|
|
* Returns opp descriptor node for a device node, caller must
|
|
|
|
* do of_node_put().
|
|
|
|
*/
|
|
|
|
static struct device_node *_opp_of_get_opp_desc_node(struct device_node *np,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
/* "operating-points-v2" can be an array for power domain providers */
|
|
|
|
return of_parse_phandle(np, "operating-points-v2", index);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns opp descriptor node for a device, caller must do of_node_put() */
|
|
|
|
struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev)
|
|
|
|
{
|
|
|
|
return _opp_of_get_opp_desc_node(dev->of_node, 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_opp_desc_node);
|
|
|
|
|
2018-09-06 21:31:54 -06:00
|
|
|
struct opp_table *_managed_opp(struct device *dev, int index)
|
2016-05-05 04:50:33 -06:00
|
|
|
{
|
2017-01-22 21:41:45 -07:00
|
|
|
struct opp_table *opp_table, *managed_table = NULL;
|
2018-09-06 21:31:54 -06:00
|
|
|
struct device_node *np;
|
2017-01-22 21:41:45 -07:00
|
|
|
|
2018-09-06 21:31:54 -06:00
|
|
|
np = _opp_of_get_opp_desc_node(dev->of_node, index);
|
|
|
|
if (!np)
|
|
|
|
return NULL;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2017-01-22 21:41:49 -07:00
|
|
|
list_for_each_entry(opp_table, &opp_tables, node) {
|
2016-05-05 04:50:33 -06:00
|
|
|
if (opp_table->np == np) {
|
|
|
|
/*
|
|
|
|
* Multiple devices can point to the same OPP table and
|
|
|
|
* so will have same node-pointer, np.
|
|
|
|
*
|
|
|
|
* But the OPPs will be considered as shared only if the
|
|
|
|
* OPP table contains a "opp-shared" property.
|
|
|
|
*/
|
2017-01-22 21:41:45 -07:00
|
|
|
if (opp_table->shared_opp == OPP_TABLE_ACCESS_SHARED) {
|
|
|
|
_get_opp_table_kref(opp_table);
|
|
|
|
managed_table = opp_table;
|
|
|
|
}
|
2016-06-16 07:33:11 -06:00
|
|
|
|
2017-01-22 21:41:45 -07:00
|
|
|
break;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-06 21:31:54 -06:00
|
|
|
of_node_put(np);
|
2017-01-22 21:41:45 -07:00
|
|
|
|
|
|
|
return managed_table;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
/* The caller must call dev_pm_opp_put() after the OPP is used */
|
|
|
|
static struct dev_pm_opp *_find_opp_of_np(struct opp_table *opp_table,
|
|
|
|
struct device_node *opp_np)
|
|
|
|
{
|
|
|
|
struct dev_pm_opp *opp;
|
|
|
|
|
|
|
|
lockdep_assert_held(&opp_table_lock);
|
|
|
|
|
|
|
|
mutex_lock(&opp_table->lock);
|
|
|
|
|
|
|
|
list_for_each_entry(opp, &opp_table->opp_list, node) {
|
|
|
|
if (opp->np == opp_np) {
|
|
|
|
dev_pm_opp_get(opp);
|
|
|
|
mutex_unlock(&opp_table->lock);
|
|
|
|
return opp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&opp_table->lock);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct device_node *of_parse_required_opp(struct device_node *np,
|
|
|
|
int index)
|
|
|
|
{
|
|
|
|
struct device_node *required_np;
|
|
|
|
|
|
|
|
required_np = of_parse_phandle(np, "required-opps", index);
|
|
|
|
if (unlikely(!required_np)) {
|
|
|
|
pr_err("%s: Unable to parse required-opps: %pOF, index: %d\n",
|
|
|
|
__func__, np, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
return required_np;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The caller must call dev_pm_opp_put_opp_table() after the table is used */
|
|
|
|
static struct opp_table *_find_table_of_opp_np(struct device_node *opp_np)
|
|
|
|
{
|
|
|
|
struct opp_table *opp_table;
|
2018-11-21 22:34:00 -07:00
|
|
|
struct device_node *opp_table_np;
|
2018-06-07 03:20:43 -06:00
|
|
|
|
|
|
|
lockdep_assert_held(&opp_table_lock);
|
|
|
|
|
2018-11-21 22:34:00 -07:00
|
|
|
opp_table_np = of_get_parent(opp_np);
|
|
|
|
if (!opp_table_np)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
/* It is safe to put the node now as all we need now is its address */
|
|
|
|
of_node_put(opp_table_np);
|
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
list_for_each_entry(opp_table, &opp_tables, node) {
|
2018-11-21 22:34:00 -07:00
|
|
|
if (opp_table_np == opp_table->np) {
|
2018-06-07 03:20:43 -06:00
|
|
|
_get_opp_table_kref(opp_table);
|
|
|
|
return opp_table;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-21 22:34:00 -07:00
|
|
|
err:
|
2018-06-07 03:20:43 -06:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free resources previously acquired by _opp_table_alloc_required_tables() */
|
|
|
|
static void _opp_table_free_required_tables(struct opp_table *opp_table)
|
|
|
|
{
|
|
|
|
struct opp_table **required_opp_tables = opp_table->required_opp_tables;
|
2018-06-26 04:59:34 -06:00
|
|
|
struct device **genpd_virt_devs = opp_table->genpd_virt_devs;
|
2018-06-07 03:20:43 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!required_opp_tables)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < opp_table->required_opp_count; i++) {
|
|
|
|
if (IS_ERR_OR_NULL(required_opp_tables[i]))
|
|
|
|
break;
|
|
|
|
|
|
|
|
dev_pm_opp_put_opp_table(required_opp_tables[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(required_opp_tables);
|
2018-06-26 04:59:34 -06:00
|
|
|
kfree(genpd_virt_devs);
|
2018-06-07 03:20:43 -06:00
|
|
|
|
|
|
|
opp_table->required_opp_count = 0;
|
2018-06-26 04:59:34 -06:00
|
|
|
opp_table->genpd_virt_devs = NULL;
|
2018-06-07 03:20:43 -06:00
|
|
|
opp_table->required_opp_tables = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Populate all devices and opp tables which are part of "required-opps" list.
|
|
|
|
* Checking only the first OPP node should be enough.
|
|
|
|
*/
|
|
|
|
static void _opp_table_alloc_required_tables(struct opp_table *opp_table,
|
|
|
|
struct device *dev,
|
|
|
|
struct device_node *opp_np)
|
|
|
|
{
|
|
|
|
struct opp_table **required_opp_tables;
|
2018-06-26 04:59:34 -06:00
|
|
|
struct device **genpd_virt_devs = NULL;
|
2018-06-07 03:20:43 -06:00
|
|
|
struct device_node *required_np, *np;
|
|
|
|
int count, i;
|
|
|
|
|
|
|
|
/* Traversing the first OPP node is all we need */
|
|
|
|
np = of_get_next_available_child(opp_np, NULL);
|
|
|
|
if (!np) {
|
|
|
|
dev_err(dev, "Empty OPP table\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = of_count_phandle_with_args(np, "required-opps", NULL);
|
|
|
|
if (!count)
|
|
|
|
goto put_np;
|
|
|
|
|
2018-06-26 04:59:34 -06:00
|
|
|
if (count > 1) {
|
|
|
|
genpd_virt_devs = kcalloc(count, sizeof(*genpd_virt_devs),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!genpd_virt_devs)
|
|
|
|
goto put_np;
|
|
|
|
}
|
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
required_opp_tables = kcalloc(count, sizeof(*required_opp_tables),
|
|
|
|
GFP_KERNEL);
|
2018-06-26 04:59:34 -06:00
|
|
|
if (!required_opp_tables) {
|
|
|
|
kfree(genpd_virt_devs);
|
2018-06-07 03:20:43 -06:00
|
|
|
goto put_np;
|
2018-06-26 04:59:34 -06:00
|
|
|
}
|
2018-06-07 03:20:43 -06:00
|
|
|
|
2018-06-26 04:59:34 -06:00
|
|
|
opp_table->genpd_virt_devs = genpd_virt_devs;
|
2018-06-07 03:20:43 -06:00
|
|
|
opp_table->required_opp_tables = required_opp_tables;
|
|
|
|
opp_table->required_opp_count = count;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
required_np = of_parse_required_opp(np, i);
|
|
|
|
if (!required_np)
|
|
|
|
goto free_required_tables;
|
|
|
|
|
|
|
|
required_opp_tables[i] = _find_table_of_opp_np(required_np);
|
|
|
|
of_node_put(required_np);
|
|
|
|
|
|
|
|
if (IS_ERR(required_opp_tables[i]))
|
|
|
|
goto free_required_tables;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only support genpd's OPPs in the "required-opps" for now,
|
|
|
|
* as we don't know how much about other cases. Error out if the
|
|
|
|
* required OPP doesn't belong to a genpd.
|
|
|
|
*/
|
|
|
|
if (!required_opp_tables[i]->is_genpd) {
|
|
|
|
dev_err(dev, "required-opp doesn't belong to genpd: %pOF\n",
|
|
|
|
required_np);
|
|
|
|
goto free_required_tables;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
goto put_np;
|
|
|
|
|
|
|
|
free_required_tables:
|
|
|
|
_opp_table_free_required_tables(opp_table);
|
|
|
|
put_np:
|
|
|
|
of_node_put(np);
|
|
|
|
}
|
|
|
|
|
2018-09-05 04:47:14 -06:00
|
|
|
void _of_init_opp_table(struct opp_table *opp_table, struct device *dev,
|
|
|
|
int index)
|
2016-05-05 04:50:33 -06:00
|
|
|
{
|
2018-06-14 00:34:43 -06:00
|
|
|
struct device_node *np, *opp_np;
|
|
|
|
u32 val;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Only required for backward compatibility with v1 bindings, but isn't
|
|
|
|
* harmful for other cases. And so we do it unconditionally.
|
|
|
|
*/
|
|
|
|
np = of_node_get(dev->of_node);
|
2018-06-14 00:34:43 -06:00
|
|
|
if (!np)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!of_property_read_u32(np, "clock-latency", &val))
|
|
|
|
opp_table->clock_latency_ns_max = val;
|
|
|
|
of_property_read_u32(np, "voltage-tolerance",
|
|
|
|
&opp_table->voltage_tolerance_v1);
|
|
|
|
|
2018-06-13 04:30:11 -06:00
|
|
|
if (of_find_property(np, "#power-domain-cells", NULL))
|
|
|
|
opp_table->is_genpd = true;
|
|
|
|
|
2018-06-14 00:34:43 -06:00
|
|
|
/* Get OPP table node */
|
|
|
|
opp_np = _opp_of_get_opp_desc_node(np, index);
|
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
if (!opp_np)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (of_property_read_bool(opp_np, "opp-shared"))
|
|
|
|
opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED;
|
|
|
|
else
|
|
|
|
opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE;
|
|
|
|
|
|
|
|
opp_table->np = opp_np;
|
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
_opp_table_alloc_required_tables(opp_table, dev, opp_np);
|
2018-06-14 00:34:43 -06:00
|
|
|
of_node_put(opp_np);
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
void _of_clear_opp_table(struct opp_table *opp_table)
|
|
|
|
{
|
|
|
|
_opp_table_free_required_tables(opp_table);
|
|
|
|
}
|
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
/*
|
|
|
|
* Release all resources previously acquired with a call to
|
|
|
|
* _of_opp_alloc_required_opps().
|
|
|
|
*/
|
|
|
|
void _of_opp_free_required_opps(struct opp_table *opp_table,
|
|
|
|
struct dev_pm_opp *opp)
|
|
|
|
{
|
|
|
|
struct dev_pm_opp **required_opps = opp->required_opps;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!required_opps)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < opp_table->required_opp_count; i++) {
|
|
|
|
if (!required_opps[i])
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Put the reference back */
|
|
|
|
dev_pm_opp_put(required_opps[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(required_opps);
|
|
|
|
opp->required_opps = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Populate all required OPPs which are part of "required-opps" list */
|
|
|
|
static int _of_opp_alloc_required_opps(struct opp_table *opp_table,
|
|
|
|
struct dev_pm_opp *opp)
|
|
|
|
{
|
|
|
|
struct dev_pm_opp **required_opps;
|
|
|
|
struct opp_table *required_table;
|
|
|
|
struct device_node *np;
|
|
|
|
int i, ret, count = opp_table->required_opp_count;
|
|
|
|
|
|
|
|
if (!count)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
required_opps = kcalloc(count, sizeof(*required_opps), GFP_KERNEL);
|
|
|
|
if (!required_opps)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
opp->required_opps = required_opps;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
required_table = opp_table->required_opp_tables[i];
|
|
|
|
|
|
|
|
np = of_parse_required_opp(opp->np, i);
|
|
|
|
if (unlikely(!np)) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto free_required_opps;
|
|
|
|
}
|
|
|
|
|
|
|
|
required_opps[i] = _find_opp_of_np(required_table, np);
|
|
|
|
of_node_put(np);
|
|
|
|
|
|
|
|
if (!required_opps[i]) {
|
|
|
|
pr_err("%s: Unable to find required OPP node: %pOF (%d)\n",
|
|
|
|
__func__, opp->np, i);
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto free_required_opps;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
free_required_opps:
|
|
|
|
_of_opp_free_required_opps(opp_table, opp);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-05-05 04:50:33 -06:00
|
|
|
static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table,
|
|
|
|
struct device_node *np)
|
|
|
|
{
|
|
|
|
unsigned int count = opp_table->supported_hw_count;
|
|
|
|
u32 version;
|
|
|
|
int ret;
|
|
|
|
|
2016-09-23 14:07:47 -06:00
|
|
|
if (!opp_table->supported_hw) {
|
|
|
|
/*
|
|
|
|
* In the case that no supported_hw has been set by the
|
|
|
|
* platform but there is an opp-supported-hw value set for
|
|
|
|
* an OPP then the OPP should not be enabled as there is
|
|
|
|
* no way to see if the hardware supports it.
|
|
|
|
*/
|
|
|
|
if (of_find_property(np, "opp-supported-hw", NULL))
|
|
|
|
return false;
|
|
|
|
else
|
|
|
|
return true;
|
|
|
|
}
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
while (count--) {
|
|
|
|
ret = of_property_read_u32_index(np, "opp-supported-hw", count,
|
|
|
|
&version);
|
|
|
|
if (ret) {
|
|
|
|
dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",
|
|
|
|
__func__, count, ret);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Both of these are bitwise masks of the versions */
|
|
|
|
if (!(version & opp_table->supported_hw[count]))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,
|
|
|
|
struct opp_table *opp_table)
|
|
|
|
{
|
2016-12-01 03:58:19 -07:00
|
|
|
u32 *microvolt, *microamp = NULL;
|
2018-12-11 04:09:36 -07:00
|
|
|
int supplies = opp_table->regulator_count, vcount, icount, ret, i, j;
|
2016-05-05 04:50:33 -06:00
|
|
|
struct property *prop = NULL;
|
|
|
|
char name[NAME_MAX];
|
|
|
|
|
|
|
|
/* Search for "opp-microvolt-<name>" */
|
|
|
|
if (opp_table->prop_name) {
|
|
|
|
snprintf(name, sizeof(name), "opp-microvolt-%s",
|
|
|
|
opp_table->prop_name);
|
|
|
|
prop = of_find_property(opp->np, name, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
/* Search for "opp-microvolt" */
|
|
|
|
sprintf(name, "opp-microvolt");
|
|
|
|
prop = of_find_property(opp->np, name, NULL);
|
|
|
|
|
|
|
|
/* Missing property isn't a problem, but an invalid entry is */
|
2017-05-22 22:02:12 -06:00
|
|
|
if (!prop) {
|
2018-12-11 04:09:36 -07:00
|
|
|
if (unlikely(supplies == -1)) {
|
|
|
|
/* Initialize regulator_count */
|
|
|
|
opp_table->regulator_count = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!supplies)
|
2017-05-22 22:02:12 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n",
|
|
|
|
__func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
2018-12-11 04:09:36 -07:00
|
|
|
if (unlikely(supplies == -1)) {
|
|
|
|
/* Initialize regulator_count */
|
|
|
|
supplies = opp_table->regulator_count = 1;
|
|
|
|
} else if (unlikely(!supplies)) {
|
|
|
|
dev_err(dev, "%s: opp-microvolt wasn't expected\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-12-01 03:58:19 -07:00
|
|
|
vcount = of_property_count_u32_elems(opp->np, name);
|
|
|
|
if (vcount < 0) {
|
2016-05-05 04:50:33 -06:00
|
|
|
dev_err(dev, "%s: Invalid %s property (%d)\n",
|
2016-12-01 03:58:19 -07:00
|
|
|
__func__, name, vcount);
|
|
|
|
return vcount;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
2016-12-01 03:58:19 -07:00
|
|
|
/* There can be one or three elements per supply */
|
|
|
|
if (vcount != supplies && vcount != supplies * 3) {
|
|
|
|
dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n",
|
|
|
|
__func__, name, vcount, supplies);
|
2016-05-05 04:50:33 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-12-01 03:58:19 -07:00
|
|
|
microvolt = kmalloc_array(vcount, sizeof(*microvolt), GFP_KERNEL);
|
|
|
|
if (!microvolt)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = of_property_read_u32_array(opp->np, name, microvolt, vcount);
|
2016-05-05 04:50:33 -06:00
|
|
|
if (ret) {
|
|
|
|
dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);
|
2016-12-01 03:58:19 -07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto free_microvolt;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Search for "opp-microamp-<name>" */
|
|
|
|
prop = NULL;
|
|
|
|
if (opp_table->prop_name) {
|
|
|
|
snprintf(name, sizeof(name), "opp-microamp-%s",
|
|
|
|
opp_table->prop_name);
|
|
|
|
prop = of_find_property(opp->np, name, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
/* Search for "opp-microamp" */
|
|
|
|
sprintf(name, "opp-microamp");
|
|
|
|
prop = of_find_property(opp->np, name, NULL);
|
|
|
|
}
|
|
|
|
|
2016-12-01 03:58:19 -07:00
|
|
|
if (prop) {
|
|
|
|
icount = of_property_count_u32_elems(opp->np, name);
|
|
|
|
if (icount < 0) {
|
|
|
|
dev_err(dev, "%s: Invalid %s property (%d)\n", __func__,
|
|
|
|
name, icount);
|
|
|
|
ret = icount;
|
|
|
|
goto free_microvolt;
|
|
|
|
}
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2016-12-01 03:58:19 -07:00
|
|
|
if (icount != supplies) {
|
|
|
|
dev_err(dev, "%s: Invalid number of elements in %s property (%d) with supplies (%d)\n",
|
|
|
|
__func__, name, icount, supplies);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto free_microvolt;
|
|
|
|
}
|
|
|
|
|
|
|
|
microamp = kmalloc_array(icount, sizeof(*microamp), GFP_KERNEL);
|
|
|
|
if (!microamp) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto free_microvolt;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = of_property_read_u32_array(opp->np, name, microamp,
|
|
|
|
icount);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(dev, "%s: error parsing %s: %d\n", __func__,
|
|
|
|
name, ret);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto free_microamp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0, j = 0; i < supplies; i++) {
|
|
|
|
opp->supplies[i].u_volt = microvolt[j++];
|
|
|
|
|
|
|
|
if (vcount == supplies) {
|
|
|
|
opp->supplies[i].u_volt_min = opp->supplies[i].u_volt;
|
|
|
|
opp->supplies[i].u_volt_max = opp->supplies[i].u_volt;
|
|
|
|
} else {
|
|
|
|
opp->supplies[i].u_volt_min = microvolt[j++];
|
|
|
|
opp->supplies[i].u_volt_max = microvolt[j++];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (microamp)
|
|
|
|
opp->supplies[i].u_amp = microamp[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
free_microamp:
|
|
|
|
kfree(microamp);
|
|
|
|
free_microvolt:
|
|
|
|
kfree(microvolt);
|
|
|
|
|
|
|
|
return ret;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
|
|
|
|
* entries
|
|
|
|
* @dev: device pointer used to lookup OPP table.
|
|
|
|
*
|
|
|
|
* Free OPPs created using static entries present in DT.
|
|
|
|
*/
|
|
|
|
void dev_pm_opp_of_remove_table(struct device *dev)
|
|
|
|
{
|
2018-09-13 01:44:36 -06:00
|
|
|
_dev_pm_opp_find_and_remove_table(dev);
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
|
2017-01-02 02:11:01 -07:00
|
|
|
* @opp_table: OPP table
|
2016-05-05 04:50:33 -06:00
|
|
|
* @dev: device for which we do this operation
|
|
|
|
* @np: device node
|
|
|
|
*
|
|
|
|
* This function adds an opp definition to the opp table and returns status. The
|
|
|
|
* opp can be controlled using dev_pm_opp_enable/disable functions and may be
|
|
|
|
* removed by dev_pm_opp_remove.
|
|
|
|
*
|
|
|
|
* Return:
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
* Valid OPP pointer:
|
|
|
|
* On success
|
|
|
|
* NULL:
|
2016-05-05 04:50:33 -06:00
|
|
|
* Duplicate OPPs (both freq and volt are same) and opp->available
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
* OR if the OPP is not supported by hardware.
|
|
|
|
* ERR_PTR(-EEXIST):
|
|
|
|
* Freq are same and volt are different OR
|
2016-05-05 04:50:33 -06:00
|
|
|
* Duplicate OPPs (both freq and volt are same) and !opp->available
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
* ERR_PTR(-ENOMEM):
|
|
|
|
* Memory allocation failure
|
|
|
|
* ERR_PTR(-EINVAL):
|
|
|
|
* Failed parsing the OPP node
|
2016-05-05 04:50:33 -06:00
|
|
|
*/
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table,
|
|
|
|
struct device *dev, struct device_node *np)
|
2016-05-05 04:50:33 -06:00
|
|
|
{
|
|
|
|
struct dev_pm_opp *new_opp;
|
2018-05-16 03:52:41 -06:00
|
|
|
u64 rate = 0;
|
2016-05-05 04:50:33 -06:00
|
|
|
u32 val;
|
|
|
|
int ret;
|
2018-04-06 03:05:45 -06:00
|
|
|
bool rate_not_available = false;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2017-01-02 02:11:01 -07:00
|
|
|
new_opp = _opp_allocate(opp_table);
|
|
|
|
if (!new_opp)
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
ret = of_property_read_u64(np, "opp-hz", &rate);
|
|
|
|
if (ret < 0) {
|
2018-04-06 03:05:45 -06:00
|
|
|
/* "opp-hz" is optional for devices like power domains. */
|
2018-06-13 04:30:11 -06:00
|
|
|
if (!opp_table->is_genpd) {
|
2018-04-06 03:05:45 -06:00
|
|
|
dev_err(dev, "%s: opp-hz not found\n", __func__);
|
|
|
|
goto free_opp;
|
|
|
|
}
|
|
|
|
|
|
|
|
rate_not_available = true;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Rate is defined as an unsigned long in clk API, and so
|
|
|
|
* casting explicitly to its type. Must be fixed once rate is 64
|
|
|
|
* bit guaranteed in clk API.
|
|
|
|
*/
|
|
|
|
new_opp->rate = (unsigned long)rate;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if the OPP supports hardware's hierarchy of versions or not */
|
|
|
|
if (!_opp_is_supported(dev, opp_table, np)) {
|
|
|
|
dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate);
|
|
|
|
goto free_opp;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_opp->turbo = of_property_read_bool(np, "turbo-mode");
|
|
|
|
|
|
|
|
new_opp->np = np;
|
|
|
|
new_opp->dynamic = false;
|
|
|
|
new_opp->available = true;
|
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
ret = _of_opp_alloc_required_opps(opp_table, new_opp);
|
|
|
|
if (ret)
|
|
|
|
goto free_opp;
|
|
|
|
|
2016-05-05 04:50:33 -06:00
|
|
|
if (!of_property_read_u32(np, "clock-latency-ns", &val))
|
|
|
|
new_opp->clock_latency_ns = val;
|
|
|
|
|
|
|
|
ret = opp_parse_supplies(new_opp, dev, opp_table);
|
|
|
|
if (ret)
|
2018-06-07 03:20:43 -06:00
|
|
|
goto free_required_opps;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-06-13 22:33:26 -06:00
|
|
|
if (opp_table->is_genpd)
|
|
|
|
new_opp->pstate = pm_genpd_opp_to_performance_state(dev, new_opp);
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-04-06 03:05:45 -06:00
|
|
|
ret = _opp_add(dev, new_opp, opp_table, rate_not_available);
|
2017-01-02 02:10:55 -07:00
|
|
|
if (ret) {
|
|
|
|
/* Don't return error for duplicate OPPs */
|
|
|
|
if (ret == -EBUSY)
|
|
|
|
ret = 0;
|
2018-06-07 03:20:43 -06:00
|
|
|
goto free_required_opps;
|
2017-01-02 02:10:55 -07:00
|
|
|
}
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
/* OPP to select on device suspend */
|
|
|
|
if (of_property_read_bool(np, "opp-suspend")) {
|
|
|
|
if (opp_table->suspend_opp) {
|
|
|
|
dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
|
|
|
|
__func__, opp_table->suspend_opp->rate,
|
|
|
|
new_opp->rate);
|
|
|
|
} else {
|
|
|
|
new_opp->suspend = true;
|
|
|
|
opp_table->suspend_opp = new_opp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max)
|
|
|
|
opp_table->clock_latency_ns_max = new_opp->clock_latency_ns;
|
|
|
|
|
|
|
|
pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
|
2016-12-01 03:58:17 -07:00
|
|
|
__func__, new_opp->turbo, new_opp->rate,
|
2016-12-01 03:58:19 -07:00
|
|
|
new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min,
|
|
|
|
new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns);
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Notify the changes in the availability of the operable
|
|
|
|
* frequency/voltage list.
|
|
|
|
*/
|
2017-01-22 21:41:49 -07:00
|
|
|
blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp);
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
return new_opp;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-06-07 03:20:43 -06:00
|
|
|
free_required_opps:
|
|
|
|
_of_opp_free_required_opps(opp_table, new_opp);
|
2016-05-05 04:50:33 -06:00
|
|
|
free_opp:
|
2017-01-02 02:11:01 -07:00
|
|
|
_opp_free(new_opp);
|
|
|
|
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
return ERR_PTR(ret);
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initializes OPP tables based on new bindings */
|
2018-09-11 23:51:17 -06:00
|
|
|
static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table)
|
2016-05-05 04:50:33 -06:00
|
|
|
{
|
|
|
|
struct device_node *np;
|
2018-09-06 21:31:54 -06:00
|
|
|
int ret, count = 0, pstate_count = 0;
|
2016-11-18 03:17:46 -07:00
|
|
|
struct dev_pm_opp *opp;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-09-06 21:31:54 -06:00
|
|
|
/* OPP table is already initialized for the device */
|
|
|
|
if (opp_table->parsed_static_opps) {
|
|
|
|
kref_get(&opp_table->list_kref);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-09-10 23:44:11 -06:00
|
|
|
kref_init(&opp_table->list_kref);
|
|
|
|
|
2016-05-05 04:50:33 -06:00
|
|
|
/* We have opp-table node now, iterate over it and add OPPs */
|
2018-09-11 23:51:17 -06:00
|
|
|
for_each_available_child_of_node(opp_table->np, np) {
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
opp = _opp_add_static_v2(opp_table, dev, np);
|
|
|
|
if (IS_ERR(opp)) {
|
|
|
|
ret = PTR_ERR(opp);
|
2016-05-05 04:50:33 -06:00
|
|
|
dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
|
|
|
|
ret);
|
2017-10-04 00:05:03 -06:00
|
|
|
of_node_put(np);
|
2018-09-12 01:05:19 -06:00
|
|
|
goto put_list_kref;
|
PM / OPP: _of_add_opp_table_v2(): increment count only if OPP is added
Currently the _of_add_opp_table_v2 call loops through the OPP nodes in
the operating-points-v2 table in the device tree and calls
_opp_add_static_v2 for each to add them to the table. It counts each
iteration through this loop as an added OPP, however there are cases
where _opp_add_static_v2() returns 0 but no new OPP is added to the
list.
This can happen while adding duplicate OPP or if the OPP isn't supported
by hardware.
Because of this the count variable will contain the number of OPP nodes
in the table in device tree but not necessarily the ones that are
actually added.
As this count value is what is checked to determine if there are any
valid OPPs, if a platform has an operating-points-v2 table with all OPP
nodes containing opp-supported-hw values that are not currently
supported, then _of_add_opp_table_v2 will fail to abort as it should due
to an empty table.
Additionally, since commit 3ba98324e81a ("PM / OPP: Get
performance state using genpd helper"), the same count variable is
compared against the number of OPPs containing performance states and
requires that either all or none have pstates set, however in the case
of any opp table that has any entries that do not get added by
_opp_add_static_v2 due to incompatible opp-supported-hw fields, these
numbers will not match and _of_add_opp_table_v2 will incorrectly fail.
We need to clearly identify all the three cases (success, failure,
unsupported/duplicate OPPs) and then increment count only on success
case. Change return type of _opp_add_static_v2() to return the pointer
to the newly added OPP instead of an integer. This routine now returns a
valid pointer if the OPP is really added, NULL for unsupported or
duplicate OPPs, and error value cased as a pointer on errors.
Ideally the fixes tag in this commit should point back to the commit
that introduced OPP v2 initially, as that's where we started incorrectly
accounting for duplicate OPPs:
commit 274659029c9d ("PM / OPP: Add support to parse "operating-points-v2" bindings")
But it wasn't a real problem until recently as the count was only used
to check if any OPPs are added or not. And so this commit points to a
rather recent commit where we added more code that depends on the value
of "count".
Fixes: 3ba98324e81a ("PM / OPP: Get performance state using genpd helper")
Reported-by: Dave Gerlach <d-gerlach@ti.com>
Reported-by: Niklas Cassel <niklas.cassel@linaro.org>
Tested-by: Niklas Cassel <niklas.cassel@linaro.org>
Signed-off-by: Dave Gerlach <d-gerlach@ti.com>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
2018-10-03 04:43:15 -06:00
|
|
|
} else if (opp) {
|
|
|
|
count++;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* There should be one of more OPP defined */
|
2017-01-02 02:11:01 -07:00
|
|
|
if (WARN_ON(!count)) {
|
|
|
|
ret = -ENOENT;
|
2018-09-12 01:05:19 -06:00
|
|
|
goto put_list_kref;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
2016-11-18 03:17:46 -07:00
|
|
|
list_for_each_entry(opp, &opp_table->opp_list, node)
|
|
|
|
pstate_count += !!opp->pstate;
|
|
|
|
|
|
|
|
/* Either all or none of the nodes shall have performance state set */
|
|
|
|
if (pstate_count && pstate_count != count) {
|
|
|
|
dev_err(dev, "Not all nodes have performance state set (%d: %d)\n",
|
|
|
|
count, pstate_count);
|
|
|
|
ret = -ENOENT;
|
2018-09-12 01:05:19 -06:00
|
|
|
goto put_list_kref;
|
2016-11-18 03:17:46 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (pstate_count)
|
|
|
|
opp_table->genpd_performance_state = true;
|
|
|
|
|
2018-06-14 00:34:43 -06:00
|
|
|
opp_table->parsed_static_opps = true;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-09-12 01:05:19 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
put_list_kref:
|
|
|
|
_put_opp_list_kref(opp_table);
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initializes OPP tables based on old-deprecated bindings */
|
2018-09-11 23:51:17 -06:00
|
|
|
static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table)
|
2016-05-05 04:50:33 -06:00
|
|
|
{
|
|
|
|
const struct property *prop;
|
|
|
|
const __be32 *val;
|
2017-01-02 02:11:01 -07:00
|
|
|
int nr, ret = 0;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
prop = of_find_property(dev->of_node, "operating-points", NULL);
|
|
|
|
if (!prop)
|
|
|
|
return -ENODEV;
|
|
|
|
if (!prop->value)
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each OPP is a set of tuples consisting of frequency and
|
|
|
|
* voltage like <freq-kHz vol-uV>.
|
|
|
|
*/
|
|
|
|
nr = prop->length / sizeof(u32);
|
|
|
|
if (nr % 2) {
|
|
|
|
dev_err(dev, "%s: Invalid OPP table\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2018-09-10 23:44:11 -06:00
|
|
|
kref_init(&opp_table->list_kref);
|
|
|
|
|
2016-05-05 04:50:33 -06:00
|
|
|
val = prop->value;
|
|
|
|
while (nr) {
|
|
|
|
unsigned long freq = be32_to_cpup(val++) * 1000;
|
|
|
|
unsigned long volt = be32_to_cpup(val++);
|
|
|
|
|
2017-01-02 02:11:01 -07:00
|
|
|
ret = _opp_add_v1(opp_table, dev, freq, volt, false);
|
2017-01-02 02:10:58 -07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(dev, "%s: Failed to add OPP %ld (%d)\n",
|
|
|
|
__func__, freq, ret);
|
2018-09-12 01:05:19 -06:00
|
|
|
_put_opp_list_kref(opp_table);
|
|
|
|
return ret;
|
2017-01-02 02:10:58 -07:00
|
|
|
}
|
2016-05-05 04:50:33 -06:00
|
|
|
nr -= 2;
|
|
|
|
}
|
|
|
|
|
2017-01-02 02:11:01 -07:00
|
|
|
return ret;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dev_pm_opp_of_add_table() - Initialize opp table from device tree
|
|
|
|
* @dev: device pointer used to lookup OPP table.
|
|
|
|
*
|
|
|
|
* Register the initial OPP table with the OPP library for given device.
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* 0 On success OR
|
|
|
|
* Duplicate OPPs (both freq and volt are same) and opp->available
|
|
|
|
* -EEXIST Freq are same and volt are different OR
|
|
|
|
* Duplicate OPPs (both freq and volt are same) and !opp->available
|
|
|
|
* -ENOMEM Memory allocation failure
|
|
|
|
* -ENODEV when 'operating-points' property is not found or is invalid data
|
|
|
|
* in device node.
|
|
|
|
* -ENODATA when empty 'operating-points' property is found
|
|
|
|
* -EINVAL when invalid entries are found in opp-v2 table
|
|
|
|
*/
|
|
|
|
int dev_pm_opp_of_add_table(struct device *dev)
|
|
|
|
{
|
2018-09-11 23:51:17 -06:00
|
|
|
struct opp_table *opp_table;
|
2016-05-05 04:50:33 -06:00
|
|
|
int ret;
|
|
|
|
|
2018-09-11 23:51:17 -06:00
|
|
|
opp_table = dev_pm_opp_get_opp_table_indexed(dev, 0);
|
|
|
|
if (!opp_table)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2016-05-05 04:50:33 -06:00
|
|
|
/*
|
2018-09-11 23:51:17 -06:00
|
|
|
* OPPs have two version of bindings now. Also try the old (v1)
|
|
|
|
* bindings for backward compatibility with older dtbs.
|
2016-05-05 04:50:33 -06:00
|
|
|
*/
|
2018-09-11 23:51:17 -06:00
|
|
|
if (opp_table->np)
|
|
|
|
ret = _of_add_opp_table_v2(dev, opp_table);
|
|
|
|
else
|
|
|
|
ret = _of_add_opp_table_v1(dev, opp_table);
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-09-11 23:51:17 -06:00
|
|
|
if (ret)
|
|
|
|
dev_pm_opp_put_opp_table(opp_table);
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
|
|
|
|
|
2017-04-25 23:15:46 -06:00
|
|
|
/**
|
|
|
|
* dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree
|
|
|
|
* @dev: device pointer used to lookup OPP table.
|
|
|
|
* @index: Index number.
|
|
|
|
*
|
|
|
|
* Register the initial OPP table with the OPP library for given device only
|
|
|
|
* using the "operating-points-v2" property.
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* 0 On success OR
|
|
|
|
* Duplicate OPPs (both freq and volt are same) and opp->available
|
|
|
|
* -EEXIST Freq are same and volt are different OR
|
|
|
|
* Duplicate OPPs (both freq and volt are same) and !opp->available
|
|
|
|
* -ENOMEM Memory allocation failure
|
|
|
|
* -ENODEV when 'operating-points' property is not found or is invalid data
|
|
|
|
* in device node.
|
|
|
|
* -ENODATA when empty 'operating-points' property is found
|
|
|
|
* -EINVAL when invalid entries are found in opp-v2 table
|
|
|
|
*/
|
|
|
|
int dev_pm_opp_of_add_table_indexed(struct device *dev, int index)
|
|
|
|
{
|
2018-09-11 23:51:17 -06:00
|
|
|
struct opp_table *opp_table;
|
2018-05-30 03:49:38 -06:00
|
|
|
int ret, count;
|
2017-04-25 23:15:46 -06:00
|
|
|
|
2018-09-11 23:51:17 -06:00
|
|
|
if (index) {
|
2018-05-30 03:49:38 -06:00
|
|
|
/*
|
|
|
|
* If only one phandle is present, then the same OPP table
|
|
|
|
* applies for all index requests.
|
|
|
|
*/
|
|
|
|
count = of_count_phandle_with_args(dev->of_node,
|
|
|
|
"operating-points-v2", NULL);
|
2018-11-22 22:06:07 -07:00
|
|
|
if (count == 1)
|
|
|
|
index = 0;
|
2018-05-30 03:49:38 -06:00
|
|
|
}
|
2017-04-25 23:15:46 -06:00
|
|
|
|
2018-09-11 23:51:17 -06:00
|
|
|
opp_table = dev_pm_opp_get_opp_table_indexed(dev, index);
|
|
|
|
if (!opp_table)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = _of_add_opp_table_v2(dev, opp_table);
|
|
|
|
if (ret)
|
|
|
|
dev_pm_opp_put_opp_table(opp_table);
|
2017-04-25 23:15:46 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed);
|
|
|
|
|
2016-05-05 04:50:33 -06:00
|
|
|
/* CPU device specific helpers */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask
|
|
|
|
* @cpumask: cpumask for which OPP table needs to be removed
|
|
|
|
*
|
|
|
|
* This removes the OPP tables for CPUs present in the @cpumask.
|
|
|
|
* This should be used only to remove static entries created from DT.
|
|
|
|
*/
|
|
|
|
void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)
|
|
|
|
{
|
2018-09-13 01:44:36 -06:00
|
|
|
_dev_pm_opp_cpumask_remove_table(cpumask, -1);
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask
|
|
|
|
* @cpumask: cpumask for which OPP table needs to be added.
|
|
|
|
*
|
|
|
|
* This adds the OPP tables for CPUs present in the @cpumask.
|
|
|
|
*/
|
|
|
|
int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)
|
|
|
|
{
|
|
|
|
struct device *cpu_dev;
|
2018-10-03 03:42:06 -06:00
|
|
|
int cpu, ret;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-10-03 03:42:06 -06:00
|
|
|
if (WARN_ON(cpumask_empty(cpumask)))
|
|
|
|
return -ENODEV;
|
2016-05-05 04:50:33 -06:00
|
|
|
|
|
|
|
for_each_cpu(cpu, cpumask) {
|
|
|
|
cpu_dev = get_cpu_device(cpu);
|
|
|
|
if (!cpu_dev) {
|
|
|
|
pr_err("%s: failed to get cpu%d device\n", __func__,
|
|
|
|
cpu);
|
2018-10-03 03:42:06 -06:00
|
|
|
ret = -ENODEV;
|
|
|
|
goto remove_table;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = dev_pm_opp_of_add_table(cpu_dev);
|
|
|
|
if (ret) {
|
2017-07-11 21:51:49 -06:00
|
|
|
/*
|
|
|
|
* OPP may get registered dynamically, don't print error
|
|
|
|
* message here.
|
|
|
|
*/
|
|
|
|
pr_debug("%s: couldn't find opp table for cpu:%d, %d\n",
|
|
|
|
__func__, cpu, ret);
|
2016-05-05 04:50:33 -06:00
|
|
|
|
2018-10-03 03:42:06 -06:00
|
|
|
goto remove_table;
|
2016-05-05 04:50:33 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-03 03:42:06 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
remove_table:
|
|
|
|
/* Free all other OPPs */
|
|
|
|
_dev_pm_opp_cpumask_remove_table(cpumask, cpu);
|
|
|
|
|
2016-05-05 04:50:33 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Works only for OPP v2 bindings.
|
|
|
|
*
|
|
|
|
* Returns -ENOENT if operating-points-v2 bindings aren't supported.
|
|
|
|
*/
|
|
|
|
/**
|
|
|
|
* dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with
|
|
|
|
* @cpu_dev using operating-points-v2
|
|
|
|
* bindings.
|
|
|
|
*
|
|
|
|
* @cpu_dev: CPU device for which we do this operation
|
|
|
|
* @cpumask: cpumask to update with information of sharing CPUs
|
|
|
|
*
|
|
|
|
* This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev.
|
|
|
|
*
|
|
|
|
* Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev.
|
|
|
|
*/
|
|
|
|
int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev,
|
|
|
|
struct cpumask *cpumask)
|
|
|
|
{
|
2017-07-27 04:01:17 -06:00
|
|
|
struct device_node *np, *tmp_np, *cpu_np;
|
2016-05-05 04:50:33 -06:00
|
|
|
int cpu, ret = 0;
|
|
|
|
|
|
|
|
/* Get OPP descriptor node */
|
2017-02-03 10:29:26 -07:00
|
|
|
np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);
|
2016-05-05 04:50:33 -06:00
|
|
|
if (!np) {
|
2016-10-20 01:12:49 -06:00
|
|
|
dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__);
|
2016-05-05 04:50:33 -06:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
cpumask_set_cpu(cpu_dev->id, cpumask);
|
|
|
|
|
|
|
|
/* OPPs are shared ? */
|
|
|
|
if (!of_property_read_bool(np, "opp-shared"))
|
|
|
|
goto put_cpu_node;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
if (cpu == cpu_dev->id)
|
|
|
|
continue;
|
|
|
|
|
2017-10-12 04:32:23 -06:00
|
|
|
cpu_np = of_cpu_device_node_get(cpu);
|
2017-07-27 04:01:17 -06:00
|
|
|
if (!cpu_np) {
|
|
|
|
dev_err(cpu_dev, "%s: failed to get cpu%d node\n",
|
2016-05-05 04:50:33 -06:00
|
|
|
__func__, cpu);
|
2017-07-27 04:01:17 -06:00
|
|
|
ret = -ENOENT;
|
2016-05-05 04:50:33 -06:00
|
|
|
goto put_cpu_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get OPP descriptor node */
|
2017-04-25 23:15:46 -06:00
|
|
|
tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0);
|
2017-10-12 04:32:23 -06:00
|
|
|
of_node_put(cpu_np);
|
2016-05-05 04:50:33 -06:00
|
|
|
if (!tmp_np) {
|
2017-07-27 04:01:17 -06:00
|
|
|
pr_err("%pOF: Couldn't find opp node\n", cpu_np);
|
2016-05-05 04:50:33 -06:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto put_cpu_node;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CPUs are sharing opp node */
|
|
|
|
if (np == tmp_np)
|
|
|
|
cpumask_set_cpu(cpu, cpumask);
|
|
|
|
|
|
|
|
of_node_put(tmp_np);
|
|
|
|
}
|
|
|
|
|
|
|
|
put_cpu_node:
|
|
|
|
of_node_put(np);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
|
2017-11-29 02:48:36 -07:00
|
|
|
|
|
|
|
/**
|
2018-06-27 04:59:50 -06:00
|
|
|
* of_get_required_opp_performance_state() - Search for required OPP and return its performance state.
|
2017-11-29 02:48:36 -07:00
|
|
|
* @np: Node that contains the "required-opps" property.
|
2018-06-27 04:59:50 -06:00
|
|
|
* @index: Index of the phandle to parse.
|
2017-11-29 02:48:36 -07:00
|
|
|
*
|
2018-06-27 04:59:50 -06:00
|
|
|
* Returns the performance state of the OPP pointed out by the "required-opps"
|
|
|
|
* property at @index in @np.
|
2017-11-29 02:48:36 -07:00
|
|
|
*
|
2018-12-14 02:50:56 -07:00
|
|
|
* Return: Zero or positive performance state on success, otherwise negative
|
|
|
|
* value on errors.
|
2017-11-29 02:48:36 -07:00
|
|
|
*/
|
2018-12-14 02:50:56 -07:00
|
|
|
int of_get_required_opp_performance_state(struct device_node *np, int index)
|
2017-11-29 02:48:36 -07:00
|
|
|
{
|
2018-06-27 04:59:50 -06:00
|
|
|
struct dev_pm_opp *opp;
|
2017-11-29 02:48:36 -07:00
|
|
|
struct device_node *required_np;
|
|
|
|
struct opp_table *opp_table;
|
2018-12-14 02:50:56 -07:00
|
|
|
int pstate = -EINVAL;
|
2017-11-29 02:48:36 -07:00
|
|
|
|
2018-06-27 04:59:50 -06:00
|
|
|
required_np = of_parse_required_opp(np, index);
|
|
|
|
if (!required_np)
|
2018-12-14 02:50:56 -07:00
|
|
|
return -EINVAL;
|
2017-11-29 02:48:36 -07:00
|
|
|
|
2018-06-27 04:59:50 -06:00
|
|
|
opp_table = _find_table_of_opp_np(required_np);
|
|
|
|
if (IS_ERR(opp_table)) {
|
|
|
|
pr_err("%s: Failed to find required OPP table %pOF: %ld\n",
|
|
|
|
__func__, np, PTR_ERR(opp_table));
|
|
|
|
goto put_required_np;
|
2017-11-29 02:48:36 -07:00
|
|
|
}
|
|
|
|
|
2018-06-27 04:59:50 -06:00
|
|
|
opp = _find_opp_of_np(opp_table, required_np);
|
|
|
|
if (opp) {
|
|
|
|
pstate = opp->pstate;
|
|
|
|
dev_pm_opp_put(opp);
|
2017-11-29 02:48:36 -07:00
|
|
|
}
|
|
|
|
|
2018-06-27 04:59:50 -06:00
|
|
|
dev_pm_opp_put_opp_table(opp_table);
|
2017-11-29 02:48:36 -07:00
|
|
|
|
2018-06-27 04:59:50 -06:00
|
|
|
put_required_np:
|
2017-11-29 02:48:36 -07:00
|
|
|
of_node_put(required_np);
|
|
|
|
|
2018-06-27 04:59:50 -06:00
|
|
|
return pstate;
|
2017-11-29 02:48:36 -07:00
|
|
|
}
|
2018-06-27 04:59:50 -06:00
|
|
|
EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state);
|
2018-01-11 21:33:45 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp
|
|
|
|
* @opp: opp for which DT node has to be returned for
|
|
|
|
*
|
|
|
|
* Return: DT node corresponding to the opp, else 0 on success.
|
|
|
|
*
|
|
|
|
* The caller needs to put the node with of_node_put() after using it.
|
|
|
|
*/
|
|
|
|
struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
|
|
|
|
{
|
|
|
|
if (IS_ERR_OR_NULL(opp)) {
|
|
|
|
pr_err("%s: Invalid parameters\n", __func__);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return of_node_get(opp->np);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
|