Merge branch 'pm-opp' into pm-cpufreq

phandle to a OPP table in their DT node. The OPP core will use this phandle to

find the operating points for the device.

Devices may want to choose OPP tables at runtime and so can provide a list of

phandles here. But only *one* of them should be chosen at runtime. This must be

accompanied by a corresponding "operating-points-names" property, to uniquely

identify the OPP tables.

If required, this can be extended for SoC vendor specfic bindings. Such bindings

should be documented as Documentation/devicetree/bindings/power/<vendor>-opp.txt

and should have a compatible description like: "operating-points-v2-<vendor>".

Optional properties:

- operating-points-names: Names of OPP tables (required if multiple OPP

  tables are present), to uniquely identify them. The same list must be present

  for all the CPUs which are sharing clock/voltage rails and hence the OPP

  tables.

* OPP Table Node

This describes the OPPs belonging to a device. This node can have following

  Entries for multiple regulators must be present in the same order as

  regulators are specified in device's DT node.

- opp-microvolt-<name>: Named opp-microvolt property. This is exactly similar to

  the above opp-microvolt property, but allows multiple voltage ranges to be

  provided for the same OPP. At runtime, the platform can pick a <name> and

  matching opp-microvolt-<name> property will be enabled for all OPPs. If the

  platform doesn't pick a specific <name> or the <name> doesn't match with any

  opp-microvolt-<name> properties, then opp-microvolt property shall be used, if

  present.

- opp-microamp: The maximum current drawn by the device in microamperes

  considering system specific parameters (such as transients, process, aging,

  maximum operating temperature range etc.) as necessary. This may be used to

  for few regulators, then this should be marked as zero for them. If it isn't

  required for any regulator, then this property need not be present.

- opp-microamp-<name>: Named opp-microamp property. Similar to

  opp-microvolt-<name> property, but for microamp instead.

- clock-latency-ns: Specifies the maximum possible transition latency (in

  nanoseconds) for switching to this OPP from any other OPP.

- opp-suspend: Marks the OPP to be used during device suspend. Only one OPP in

  the table should have this.

- opp-supported-hw: This enables us to select only a subset of OPPs from the

  larger OPP table, based on what version of the hardware we are running on. We

  still can't have multiple nodes with the same opp-hz value in OPP table.

  It's an user defined array containing a hierarchy of hardware version numbers,

  supported by the OPP. For example: a platform with hierarchy of three levels

  of versions (A, B and C), this field should be like <X Y Z>, where X

  corresponds to Version hierarchy A, Y corresponds to version hierarchy B and Z

  corresponds to version hierarchy C.

  Each level of hierarchy is represented by a 32 bit value, and so there can be

  only 32 different supported version per hierarchy. i.e. 1 bit per version. A

  value of 0xFFFFFFFF will enable the OPP for all versions for that hierarchy

  level. And a value of 0x00000000 will disable the OPP completely, and so we

  never want that to happen.

  If 32 values aren't sufficient for a version hierarchy, than that version

  hierarchy can be contained in multiple 32 bit values. i.e. <X Y Z1 Z2> in the

  above example, Z1 & Z2 refer to the version hierarchy Z.

- status: Marks the node enabled/disabled.

Example 1: Single cluster Dual-core ARM cortex A9, switch DVFS states together.

		compatible = "operating-points-v2";

		opp-shared;

		opp00 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			opp-microvolt = <970000 975000 985000>;

			opp-microamp = <70000>;

			clock-latency-ns = <300000>;

			opp-suspend;

		};

		opp01 {

		opp@1100000000 {

			opp-hz = /bits/ 64 <1100000000>;

			opp-microvolt = <980000 1000000 1010000>;

			opp-microamp = <80000>;

			clock-latency-ns = <310000>;

		};

		opp02 {

		opp@1200000000 {

			opp-hz = /bits/ 64 <1200000000>;

			opp-microvolt = <1025000>;

			clock-latency-ns = <290000>;

		 * independently.

		 */

		opp00 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			opp-microvolt = <970000 975000 985000>;

			opp-microamp = <70000>;

			clock-latency-ns = <300000>;

			opp-suspend;

		};

		opp01 {

		opp@1100000000 {

			opp-hz = /bits/ 64 <1100000000>;

			opp-microvolt = <980000 1000000 1010000>;

			opp-microamp = <80000>;

			clock-latency-ns = <310000>;

		};

		opp02 {

		opp@1200000000 {

			opp-hz = /bits/ 64 <1200000000>;

			opp-microvolt = <1025000>;

			opp-microamp = <90000;

		compatible = "operating-points-v2";

		opp-shared;

		opp00 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			opp-microvolt = <970000 975000 985000>;

			opp-microamp = <70000>;

			clock-latency-ns = <300000>;

			opp-suspend;

		};

		opp01 {

		opp@1100000000 {

			opp-hz = /bits/ 64 <1100000000>;

			opp-microvolt = <980000 1000000 1010000>;

			opp-microamp = <80000>;

			clock-latency-ns = <310000>;

		};

		opp02 {

		opp@1200000000 {

			opp-hz = /bits/ 64 <1200000000>;

			opp-microvolt = <1025000>;

			opp-microamp = <90000>;

		compatible = "operating-points-v2";

		opp-shared;

		opp10 {

		opp@1300000000 {

			opp-hz = /bits/ 64 <1300000000>;

			opp-microvolt = <1045000 1050000 1055000>;

			opp-microamp = <95000>;

			clock-latency-ns = <400000>;

			opp-suspend;

		};

		opp11 {

		opp@1400000000 {

			opp-hz = /bits/ 64 <1400000000>;

			opp-microvolt = <1075000>;

			opp-microamp = <100000>;

			clock-latency-ns = <400000>;

		};

		opp12 {

		opp@1500000000 {

			opp-hz = /bits/ 64 <1500000000>;

			opp-microvolt = <1010000 1100000 1110000>;

			opp-microamp = <95000>;

		compatible = "operating-points-v2";

		opp-shared;

		opp00 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			opp-microvolt = <970000>, /* Supply 0 */

					<960000>, /* Supply 1 */

		/* OR */

		opp00 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			opp-microvolt = <970000 975000 985000>, /* Supply 0 */

					<960000 965000 975000>, /* Supply 1 */

		/* OR */

		opp00 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			opp-microvolt = <970000 975000 985000>, /* Supply 0 */

					<960000 965000 975000>, /* Supply 1 */

	};

};

Example 5: Multiple OPP tables

Example 5: opp-supported-hw

(example: three level hierarchy of versions: cuts, substrate and process)

/ {

	cpus {

			...

			cpu-supply = <&cpu_supply>

			operating-points-v2 = <&cpu0_opp_table_slow>, <&cpu0_opp_table_fast>;

			operating-points-names = "slow", "fast";

			operating-points-v2 = <&cpu0_opp_table_slow>;

		};

	};

	cpu0_opp_table_slow: opp_table_slow {

	opp_table {

		compatible = "operating-points-v2";

		status = "okay";

		opp-shared;

		opp00 {

		opp@600000000 {

			/*

			 * Supports all substrate and process versions for 0xF

			 * cuts, i.e. only first four cuts.

			 */

			opp-supported-hw = <0xF 0xFFFFFFFF 0xFFFFFFFF>

			opp-hz = /bits/ 64 <600000000>;

			opp-microvolt = <900000 915000 925000>;

			...

		};

		opp01 {

		opp@800000000 {

			/*

			 * Supports:

			 * - cuts: only one, 6th cut (represented by 6th bit).

			 * - substrate: supports 16 different substrate versions

			 * - process: supports 9 different process versions

			 */

			opp-supported-hw = <0x20 0xff0000ff 0x0000f4f0>

			opp-hz = /bits/ 64 <800000000>;

			opp-microvolt = <900000 915000 925000>;

			...

		};

	};

};

	cpu0_opp_table_fast: opp_table_fast {

Example 6: opp-microvolt-<name>, opp-microamp-<name>:

(example: device with two possible microvolt ranges: slow and fast)

/ {

	cpus {

		cpu@0 {

			compatible = "arm,cortex-a7";

			...

			operating-points-v2 = <&cpu0_opp_table>;

		};

	};

	cpu0_opp_table: opp_table0 {

		compatible = "operating-points-v2";

		status = "okay";

		opp-shared;

		opp10 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			...

			opp-microvolt-slow = <900000 915000 925000>;

			opp-microvolt-fast = <970000 975000 985000>;

			opp-microamp-slow =  <70000>;

			opp-microamp-fast =  <71000>;

		};

		opp11 {

			opp-hz = /bits/ 64 <1100000000>;

			...

		opp@1200000000 {

			opp-hz = /bits/ 64 <1200000000>;

			opp-microvolt-slow = <900000 915000 925000>, /* Supply vcc0 */

					      <910000 925000 935000>; /* Supply vcc1 */

			opp-microvolt-fast = <970000 975000 985000>, /* Supply vcc0 */

					     <960000 965000 975000>; /* Supply vcc1 */

			opp-microamp =  <70000>; /* Will be used for both slow/fast */

		};

	};

};

		compatible = "operating-points-v2";

		opp-shared;

		opp00 {

		opp@200000000 {

			opp-hz = /bits/ 64 <200000000>;

			opp-microvolt = <900000>;

			clock-latency-ns = <200000>;

		};

		opp01 {

		opp@300000000 {

			opp-hz = /bits/ 64 <300000000>;

			opp-microvolt = <900000>;

			clock-latency-ns = <200000>;

		};

		opp02 {

		opp@400000000 {

			opp-hz = /bits/ 64 <400000000>;

			opp-microvolt = <925000>;

			clock-latency-ns = <200000>;

		};

		opp03 {

		opp@500000000 {

			opp-hz = /bits/ 64 <500000000>;

			opp-microvolt = <950000>;

			clock-latency-ns = <200000>;

		};

		opp04 {

		opp@600000000 {

			opp-hz = /bits/ 64 <600000000>;

			opp-microvolt = <975000>;

			clock-latency-ns = <200000>;

		};

		opp05 {

		opp@700000000 {

			opp-hz = /bits/ 64 <700000000>;

			opp-microvolt = <987500>;

			clock-latency-ns = <200000>;

		};

		opp06 {

		opp@800000000 {

			opp-hz = /bits/ 64 <800000000>;

			opp-microvolt = <1000000>;

			clock-latency-ns = <200000>;

			opp-suspend;

		};

		opp07 {

		opp@900000000 {

			opp-hz = /bits/ 64 <900000000>;

			opp-microvolt = <1037500>;

			clock-latency-ns = <200000>;

		};

		opp08 {

		opp@1000000000 {

			opp-hz = /bits/ 64 <1000000000>;

			opp-microvolt = <1087500>;

			clock-latency-ns = <200000>;

		};

		opp09 {

		opp@1100000000 {

			opp-hz = /bits/ 64 <1100000000>;

			opp-microvolt = <1137500>;

			clock-latency-ns = <200000>;

		};

		opp10 {

		opp@1200000000 {

			opp-hz = /bits/ 64 <1200000000>;

			opp-microvolt = <1187500>;

			clock-latency-ns = <200000>;

		};

		opp11 {

		opp@1300000000 {

			opp-hz = /bits/ 64 <1300000000>;

			opp-microvolt = <1250000>;

			clock-latency-ns = <200000>;

		};

		opp12 {

		opp@1400000000 {

			opp-hz = /bits/ 64 <1400000000>;

			opp-microvolt = <1287500>;

			clock-latency-ns = <200000>;

		};

		opp13 {

		opp@1500000000 {

			opp-hz = /bits/ 64 <1500000000>;

			opp-microvolt = <1350000>;

			clock-latency-ns = <200000>;

ccflags-$(CONFIG_DEBUG_DRIVER)	:= -DDEBUG

obj-y				+= core.o cpu.o

obj-$(CONFIG_DEBUG_FS)		+= debugfs.o

static void _remove_list_dev(struct device_list_opp *list_dev,

			     struct device_opp *dev_opp)

{

	opp_debug_unregister(list_dev, dev_opp);

	list_del(&list_dev->node);

	call_srcu(&dev_opp->srcu_head.srcu, &list_dev->rcu_head,

		  _kfree_list_dev_rcu);

				      struct device_opp *dev_opp)

{

	struct device_list_opp *list_dev;

	int ret;

	list_dev = kzalloc(sizeof(*list_dev), GFP_KERNEL);

	if (!list_dev)

	list_dev->dev = dev;

	list_add_rcu(&list_dev->node, &dev_opp->dev_list);

	/* Create debugfs entries for the dev_opp */

	ret = opp_debug_register(list_dev, dev_opp);

	if (ret)

		dev_err(dev, "%s: Failed to register opp debugfs (%d)\n",

			__func__, ret);

	return list_dev;

}

	if (!list_empty(&dev_opp->opp_list))

		return;

	if (dev_opp->supported_hw)

		return;

	if (dev_opp->prop_name)

		return;

	list_dev = list_first_entry(&dev_opp->dev_list, struct device_list_opp,

				    node);

	 */

	if (notify)

		srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);

	opp_debug_remove_one(opp);

	list_del_rcu(&opp->node);

	call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);

{

	struct dev_pm_opp *opp;

	struct list_head *head = &dev_opp->opp_list;

	int ret;

	/*

	 * Insert new OPP in order of increasing frequency and discard if

	new_opp->dev_opp = dev_opp;

	list_add_rcu(&new_opp->node, head);

	ret = opp_debug_create_one(new_opp, dev_opp);

	if (ret)

		dev_err(dev, "%s: Failed to register opp to debugfs (%d)\n",

			__func__, ret);

	return 0;

}

}

/* TODO: Support multiple regulators */

static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev)

static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,

			      struct device_opp *dev_opp)

{

	u32 microvolt[3] = {0};

	u32 val;

	int count, ret;

	struct property *prop = NULL;

	char name[NAME_MAX];

	/* Search for "opp-microvolt-<name>" */

	if (dev_opp->prop_name) {

		sprintf(name, "opp-microvolt-%s", dev_opp->prop_name);

		prop = of_find_property(opp->np, name, NULL);

	}

	if (!prop) {

		/* Search for "opp-microvolt" */

		name[13] = '\0';

		prop = of_find_property(opp->np, name, NULL);

		/* Missing property isn't a problem, but an invalid entry is */

	if (!of_find_property(opp->np, "opp-microvolt", NULL))

		if (!prop)

			return 0;

	}

	count = of_property_count_u32_elems(opp->np, "opp-microvolt");

	count = of_property_count_u32_elems(opp->np, name);

	if (count < 0) {

		dev_err(dev, "%s: Invalid opp-microvolt property (%d)\n",

			__func__, count);

		dev_err(dev, "%s: Invalid %s property (%d)\n",

			__func__, name, count);

		return count;

	}

	/* There can be one or three elements here */

	if (count != 1 && count != 3) {

		dev_err(dev, "%s: Invalid number of elements in opp-microvolt property (%d)\n",

			__func__, count);

		dev_err(dev, "%s: Invalid number of elements in %s property (%d)\n",

			__func__, name, count);

		return -EINVAL;

	}

	ret = of_property_read_u32_array(opp->np, "opp-microvolt", microvolt,

					 count);

	ret = of_property_read_u32_array(opp->np, name, microvolt, count);

	if (ret) {

		dev_err(dev, "%s: error parsing opp-microvolt: %d\n", __func__,

			ret);

		dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);

		return -EINVAL;

	}

	opp->u_volt_min = microvolt[1];

	opp->u_volt_max = microvolt[2];

	if (!of_property_read_u32(opp->np, "opp-microamp", &val))

	/* Search for "opp-microamp-<name>" */

	prop = NULL;

	if (dev_opp->prop_name) {

		sprintf(name, "opp-microamp-%s", dev_opp->prop_name);

		prop = of_find_property(opp->np, name, NULL);

	}

	if (!prop) {

		/* Search for "opp-microamp" */

		name[12] = '\0';

		prop = of_find_property(opp->np, name, NULL);

	}

	if (prop && !of_property_read_u32(opp->np, name, &val))

		opp->u_amp = val;

	return 0;

}

/**

 * dev_pm_opp_set_supported_hw() - Set supported platforms

 * @dev: Device for which supported-hw has to be set.

 * @versions: Array of hierarchy of versions to match.

 * @count: Number of elements in the array.

 *

 * This is required only for the V2 bindings, and it enables a platform to

 * specify the hierarchy of versions it supports. OPP layer will then enable

 * OPPs, which are available for those versions, based on its 'opp-supported-hw'

 * property.

 *

 * Locking: The internal device_opp and opp structures are RCU protected.

 * Hence this function internally uses RCU updater strategy with mutex locks

 * to keep the integrity of the internal data structures. Callers should ensure

 * that this function is *NOT* called under RCU protection or in contexts where

 * mutex cannot be locked.

 */

int dev_pm_opp_set_supported_hw(struct device *dev, const u32 *versions,

				unsigned int count)

{

	struct device_opp *dev_opp;

	int ret = 0;

	/* Hold our list modification lock here */

	mutex_lock(&dev_opp_list_lock);

	dev_opp = _add_device_opp(dev);

	if (!dev_opp) {

		ret = -ENOMEM;

		goto unlock;

	}

	/* Make sure there are no concurrent readers while updating dev_opp */

	WARN_ON(!list_empty(&dev_opp->opp_list));

	/* Do we already have a version hierarchy associated with dev_opp? */

	if (dev_opp->supported_hw) {

		dev_err(dev, "%s: Already have supported hardware list\n",

			__func__);

		ret = -EBUSY;

		goto err;

	}

	dev_opp->supported_hw = kmemdup(versions, count * sizeof(*versions),

					GFP_KERNEL);

	if (!dev_opp->supported_hw) {

		ret = -ENOMEM;

		goto err;

	}

	dev_opp->supported_hw_count = count;

	mutex_unlock(&dev_opp_list_lock);

	return 0;

err:

	_remove_device_opp(dev_opp);

unlock:

	mutex_unlock(&dev_opp_list_lock);

	return ret;

}

EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw);

/**

 * dev_pm_opp_put_supported_hw() - Releases resources blocked for supported hw

 * @dev: Device for which supported-hw has to be set.

 *

 * This is required only for the V2 bindings, and is called for a matching

 * dev_pm_opp_set_supported_hw(). Until this is called, the device_opp structure

 * will not be freed.

 *

 * Locking: The internal device_opp and opp structures are RCU protected.

 * Hence this function internally uses RCU updater strategy with mutex locks

 * to keep the integrity of the internal data structures. Callers should ensure

 * that this function is *NOT* called under RCU protection or in contexts where

 * mutex cannot be locked.

 */

void dev_pm_opp_put_supported_hw(struct device *dev)

{

	struct device_opp *dev_opp;

	/* Hold our list modification lock here */

	mutex_lock(&dev_opp_list_lock);

	/* Check for existing list for 'dev' first */

	dev_opp = _find_device_opp(dev);

	if (IS_ERR(dev_opp)) {

		dev_err(dev, "Failed to find dev_opp: %ld\n", PTR_ERR(dev_opp));

		goto unlock;

	}

	/* Make sure there are no concurrent readers while updating dev_opp */

	WARN_ON(!list_empty(&dev_opp->opp_list));

	if (!dev_opp->supported_hw) {

		dev_err(dev, "%s: Doesn't have supported hardware list\n",

			__func__);

		goto unlock;

	}

	kfree(dev_opp->supported_hw);

	dev_opp->supported_hw = NULL;

	dev_opp->supported_hw_count = 0;

	/* Try freeing device_opp if this was the last blocking resource */

	_remove_device_opp(dev_opp);

unlock:

	mutex_unlock(&dev_opp_list_lock);

}

EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw);

/**

 * dev_pm_opp_set_prop_name() - Set prop-extn name

 * @dev: Device for which the regulator has to be set.

 * @name: name to postfix to properties.

 *

 * This is required only for the V2 bindings, and it enables a platform to

 * specify the extn to be used for certain property names. The properties to

 * which the extension will apply are opp-microvolt and opp-microamp. OPP core

 * should postfix the property name with -<name> while looking for them.

 *

 * Locking: The internal device_opp and opp structures are RCU protected.

 * Hence this function internally uses RCU updater strategy with mutex locks

 * to keep the integrity of the internal data structures. Callers should ensure

 * that this function is *NOT* called under RCU protection or in contexts where

 * mutex cannot be locked.

 */

int dev_pm_opp_set_prop_name(struct device *dev, const char *name)

{

	struct device_opp *dev_opp;

	int ret = 0;

	/* Hold our list modification lock here */

	mutex_lock(&dev_opp_list_lock);

	dev_opp = _add_device_opp(dev);

	if (!dev_opp) {

		ret = -ENOMEM;

		goto unlock;

	}

	/* Make sure there are no concurrent readers while updating dev_opp */

	WARN_ON(!list_empty(&dev_opp->opp_list));

	/* Do we already have a prop-name associated with dev_opp? */

	if (dev_opp->prop_name) {

		dev_err(dev, "%s: Already have prop-name %s\n", __func__,

			dev_opp->prop_name);

		ret = -EBUSY;

		goto err;

	}

	dev_opp->prop_name = kstrdup(name, GFP_KERNEL);

	if (!dev_opp->prop_name) {

		ret = -ENOMEM;

		goto err;

	}

	mutex_unlock(&dev_opp_list_lock);

	return 0;

err:

	_remove_device_opp(dev_opp);

unlock:

	mutex_unlock(&dev_opp_list_lock);

	return ret;

}

EXPORT_SYMBOL_GPL(dev_pm_opp_set_prop_name);

/**

 * dev_pm_opp_put_prop_name() - Releases resources blocked for prop-name

 * @dev: Device for which the regulator has to be set.

 *

 * This is required only for the V2 bindings, and is called for a matching

 * dev_pm_opp_set_prop_name(). Until this is called, the device_opp structure

 * will not be freed.

 *

 * Locking: The internal device_opp and opp structures are RCU protected.

 * Hence this function internally uses RCU updater strategy with mutex locks

 * to keep the integrity of the internal data structures. Callers should ensure

 * that this function is *NOT* called under RCU protection or in contexts where

 * mutex cannot be locked.

 */

void dev_pm_opp_put_prop_name(struct device *dev)

{

	struct device_opp *dev_opp;

	/* Hold our list modification lock here */

	mutex_lock(&dev_opp_list_lock);

	/* Check for existing list for 'dev' first */

	dev_opp = _find_device_opp(dev);

	if (IS_ERR(dev_opp)) {

		dev_err(dev, "Failed to find dev_opp: %ld\n", PTR_ERR(dev_opp));

		goto unlock;

	}

	/* Make sure there are no concurrent readers while updating dev_opp */

	WARN_ON(!list_empty(&dev_opp->opp_list));

	if (!dev_opp->prop_name) {

		dev_err(dev, "%s: Doesn't have a prop-name\n", __func__);

		goto unlock;

	}

	kfree(dev_opp->prop_name);

	dev_opp->prop_name = NULL;

	/* Try freeing device_opp if this was the last blocking resource */

	_remove_device_opp(dev_opp);

unlock:

	mutex_unlock(&dev_opp_list_lock);

}

EXPORT_SYMBOL_GPL(dev_pm_opp_put_prop_name);

static bool _opp_is_supported(struct device *dev, struct device_opp *dev_opp,

			      struct device_node *np)

{

	unsigned int count = dev_opp->supported_hw_count;

	u32 version;

	int ret;

	if (!dev_opp->supported_hw)

		return true;

	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 & dev_opp->supported_hw[count]))

			return false;

	}

	return true;

}

/**

 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)

 * @dev:	device for which we do this operation

		goto free_opp;

	}

	/* Check if the OPP supports hardware's hierarchy of versions or not */

	if (!_opp_is_supported(dev, dev_opp, np)) {

		dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate);

		goto free_opp;

	}

	/*

	 * 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

	if (!of_property_read_u32(np, "clock-latency-ns", &val))

		new_opp->clock_latency_ns = val;

	ret = opp_parse_supplies(new_opp, dev);

	ret = opp_parse_supplies(new_opp, dev, dev_opp);

	if (ret)

		goto free_opp;

	/* OPP to select on device suspend */

	if (of_property_read_bool(np, "opp-suspend")) {