PM / OPP: Rename structures for clarity (2c2709dc) · Commits · e / devices / android_kernel_teracube_mt6765

drivers/base/power/opp/core.c

+379 −373

File changed.

Preview size limit exceeded, changes collapsed.

drivers/base/power/opp/cpu.c

+11 −11

Original line number	Original line	Diff line number	Diff line
	@@ -31,7 +31,7 @@
	* @table: Cpufreq table returned back to caller		* @table: Cpufreq table returned back to caller
	*		*
	* Generate a cpufreq table for a provided device- this assumes that the		* Generate a cpufreq table for a provided device- this assumes that the
	* opp list is already initialized and ready for usage.		* opp table is already initialized and ready for usage.
	*		*
	* This function allocates required memory for the cpufreq table. It is		* This function allocates required memory for the cpufreq table. It is
	* expected that the caller does the required maintenance such as freeing		* expected that the caller does the required maintenance such as freeing
	@@ -44,7 +44,7 @@
	* WARNING: It is important for the callers to ensure refreshing their copy of		* WARNING: It is important for the callers to ensure refreshing their copy of
	* the table if any of the mentioned functions have been invoked in the interim.		* the table if any of the mentioned functions have been invoked in the interim.
	*		*
	* Locking: The internal device_opp and opp structures are RCU protected.		* Locking: The internal opp_table and opp structures are RCU protected.
	* Since we just use the regular accessor functions to access the internal data		* Since we just use the regular accessor functions to access the internal data
	* structures, we use RCU read lock inside this function. As a result, users of		* structures, we use RCU read lock inside this function. As a result, users of
	* this function DONOT need to use explicit locks for invoking.		* this function DONOT need to use explicit locks for invoking.
	@@ -122,15 +122,15 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
	/* Required only for V1 bindings, as v2 can manage it from DT itself */		/* Required only for V1 bindings, as v2 can manage it from DT itself */
	int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)		int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)
	{		{
	struct device_list_opp *list_dev;		struct opp_device *opp_dev;
	struct device_opp *dev_opp;		struct opp_table *opp_table;
	struct device *dev;		struct device *dev;
	int cpu, ret = 0;		int cpu, ret = 0;

	mutex_lock(&dev_opp_list_lock);		mutex_lock(&opp_table_lock);

	dev_opp = _find_device_opp(cpu_dev);		opp_table = _find_opp_table(cpu_dev);
	if (IS_ERR(dev_opp)) {		if (IS_ERR(opp_table)) {
	ret = -EINVAL;		ret = -EINVAL;
	goto unlock;		goto unlock;
	}		}
	@@ -146,15 +146,15 @@ int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)
	continue;		continue;
	}		}

	list_dev = _add_list_dev(dev, dev_opp);		opp_dev = _add_opp_dev(dev, opp_table);
	if (!list_dev) {		if (!opp_dev) {
	dev_err(dev, "%s: failed to add list-dev for cpu%d device\n",		dev_err(dev, "%s: failed to add opp-dev for cpu%d device\n",
	__func__, cpu);		__func__, cpu);
	continue;		continue;
	}		}
	}		}
	unlock:		unlock:
	mutex_unlock(&dev_opp_list_lock);		mutex_unlock(&opp_table_lock);

	return ret;		return ret;
	}		}

drivers/base/power/opp/debugfs.c

+42 −43

Original line number	Original line	Diff line number	Diff line
	@@ -34,9 +34,9 @@ void opp_debug_remove_one(struct dev_pm_opp *opp)
	debugfs_remove_recursive(opp->dentry);		debugfs_remove_recursive(opp->dentry);
	}		}

	int opp_debug_create_one(struct dev_pm_opp opp, struct device_opp dev_opp)		int opp_debug_create_one(struct dev_pm_opp opp, struct opp_table opp_table)
	{		{
	struct dentry *pdentry = dev_opp->dentry;		struct dentry *pdentry = opp_table->dentry;
	struct dentry *d;		struct dentry *d;
	char name[25]; /* 20 chars for 64 bit value + 5 (opp:\0) */		char name[25]; /* 20 chars for 64 bit value + 5 (opp:\0) */

	@@ -83,52 +83,52 @@ int opp_debug_create_one(struct dev_pm_opp opp, struct device_opp dev_opp)
	return 0;		return 0;
	}		}

	static int device_opp_debug_create_dir(struct device_list_opp *list_dev,		static int opp_list_debug_create_dir(struct opp_device *opp_dev,
	struct device_opp *dev_opp)		struct opp_table *opp_table)
	{		{
	const struct device *dev = list_dev->dev;		const struct device *dev = opp_dev->dev;
	struct dentry *d;		struct dentry *d;

	opp_set_dev_name(dev, dev_opp->dentry_name);		opp_set_dev_name(dev, opp_table->dentry_name);

	/* Create device specific directory */		/* Create device specific directory */
	d = debugfs_create_dir(dev_opp->dentry_name, rootdir);		d = debugfs_create_dir(opp_table->dentry_name, rootdir);
	if (!d) {		if (!d) {
	dev_err(dev, "%s: Failed to create debugfs dir\n", __func__);		dev_err(dev, "%s: Failed to create debugfs dir\n", __func__);
	return -ENOMEM;		return -ENOMEM;
	}		}

	list_dev->dentry = d;		opp_dev->dentry = d;
	dev_opp->dentry = d;		opp_table->dentry = d;

	return 0;		return 0;
	}		}

	static int device_opp_debug_create_link(struct device_list_opp *list_dev,		static int opp_list_debug_create_link(struct opp_device *opp_dev,
	struct device_opp *dev_opp)		struct opp_table *opp_table)
	{		{
	const struct device *dev = list_dev->dev;		const struct device *dev = opp_dev->dev;
	char name[NAME_MAX];		char name[NAME_MAX];
	struct dentry *d;		struct dentry *d;

	opp_set_dev_name(list_dev->dev, name);		opp_set_dev_name(opp_dev->dev, name);

	/* Create device specific directory link */		/* Create device specific directory link */
	d = debugfs_create_symlink(name, rootdir, dev_opp->dentry_name);		d = debugfs_create_symlink(name, rootdir, opp_table->dentry_name);
	if (!d) {		if (!d) {
	dev_err(dev, "%s: Failed to create link\n", __func__);		dev_err(dev, "%s: Failed to create link\n", __func__);
	return -ENOMEM;		return -ENOMEM;
	}		}

	list_dev->dentry = d;		opp_dev->dentry = d;

	return 0;		return 0;
	}		}

	/**		/**
	* opp_debug_register - add a device opp node to the debugfs 'opp' directory		* opp_debug_register - add a device opp node to the debugfs 'opp' directory
	* @list_dev: list-dev pointer for device		* @opp_dev: opp-dev pointer for device
	* @dev_opp: the device-opp being added		* @opp_table: the device-opp being added
	*		*
	* Dynamically adds device specific directory in debugfs 'opp' directory. If the		* Dynamically adds device specific directory in debugfs 'opp' directory. If the
	* device-opp is shared with other devices, then links will be created for all		* device-opp is shared with other devices, then links will be created for all
	@@ -136,73 +136,72 @@ static int device_opp_debug_create_link(struct device_list_opp *list_dev,
	*		*
	* Return: 0 on success, otherwise negative error.		* Return: 0 on success, otherwise negative error.
	*/		*/
	int opp_debug_register(struct device_list_opp *list_dev,		int opp_debug_register(struct opp_device opp_dev, struct opp_table opp_table)
	struct device_opp *dev_opp)
	{		{
	if (!rootdir) {		if (!rootdir) {
	pr_debug("%s: Uninitialized rootdir\n", __func__);		pr_debug("%s: Uninitialized rootdir\n", __func__);
	return -EINVAL;		return -EINVAL;
	}		}

	if (dev_opp->dentry)		if (opp_table->dentry)
	return device_opp_debug_create_link(list_dev, dev_opp);		return opp_list_debug_create_link(opp_dev, opp_table);

	return device_opp_debug_create_dir(list_dev, dev_opp);		return opp_list_debug_create_dir(opp_dev, opp_table);
	}		}

	static void opp_migrate_dentry(struct device_list_opp *list_dev,		static void opp_migrate_dentry(struct opp_device *opp_dev,
	struct device_opp *dev_opp)		struct opp_table *opp_table)
	{		{
	struct device_list_opp *new_dev;		struct opp_device *new_dev;
	const struct device *dev;		const struct device *dev;
	struct dentry *dentry;		struct dentry *dentry;

	/* Look for next list-dev */		/* Look for next opp-dev */
	list_for_each_entry(new_dev, &dev_opp->dev_list, node)		list_for_each_entry(new_dev, &opp_table->dev_list, node)
	if (new_dev != list_dev)		if (new_dev != opp_dev)
	break;		break;

	/* new_dev is guaranteed to be valid here */		/* new_dev is guaranteed to be valid here */
	dev = new_dev->dev;		dev = new_dev->dev;
	debugfs_remove_recursive(new_dev->dentry);		debugfs_remove_recursive(new_dev->dentry);

	opp_set_dev_name(dev, dev_opp->dentry_name);		opp_set_dev_name(dev, opp_table->dentry_name);

	dentry = debugfs_rename(rootdir, list_dev->dentry, rootdir,		dentry = debugfs_rename(rootdir, opp_dev->dentry, rootdir,
	dev_opp->dentry_name);		opp_table->dentry_name);
	if (!dentry) {		if (!dentry) {
	dev_err(dev, "%s: Failed to rename link from: %s to %s\n",		dev_err(dev, "%s: Failed to rename link from: %s to %s\n",
	__func__, dev_name(list_dev->dev), dev_name(dev));		__func__, dev_name(opp_dev->dev), dev_name(dev));
	return;		return;
	}		}

	new_dev->dentry = dentry;		new_dev->dentry = dentry;
	dev_opp->dentry = dentry;		opp_table->dentry = dentry;
	}		}

	/**		/**
	* opp_debug_unregister - remove a device opp node from debugfs opp directory		* opp_debug_unregister - remove a device opp node from debugfs opp directory
	* @list_dev: list-dev pointer for device		* @opp_dev: opp-dev pointer for device
	* @dev_opp: the device-opp being removed		* @opp_table: the device-opp being removed
	*		*
	* Dynamically removes device specific directory from debugfs 'opp' directory.		* Dynamically removes device specific directory from debugfs 'opp' directory.
	*/		*/
	void opp_debug_unregister(struct device_list_opp *list_dev,		void opp_debug_unregister(struct opp_device *opp_dev,
	struct device_opp *dev_opp)		struct opp_table *opp_table)
	{		{
	if (list_dev->dentry == dev_opp->dentry) {		if (opp_dev->dentry == opp_table->dentry) {
	/* Move the real dentry object under another device */		/* Move the real dentry object under another device */
	if (!list_is_singular(&dev_opp->dev_list)) {		if (!list_is_singular(&opp_table->dev_list)) {
	opp_migrate_dentry(list_dev, dev_opp);		opp_migrate_dentry(opp_dev, opp_table);
	goto out;		goto out;
	}		}
	dev_opp->dentry = NULL;		opp_table->dentry = NULL;
	}		}

	debugfs_remove_recursive(list_dev->dentry);		debugfs_remove_recursive(opp_dev->dentry);

	out:		out:
	list_dev->dentry = NULL;		opp_dev->dentry = NULL;
	}		}

	static int __init opp_debug_init(void)		static int __init opp_debug_init(void)

drivers/base/power/opp/opp.h

+29 −32

Original line number	Original line	Diff line number	Diff line
	@@ -26,12 +26,12 @@ struct clk;
	struct regulator;		struct regulator;

	/* Lock to allow exclusive modification to the device and opp lists */		/* Lock to allow exclusive modification to the device and opp lists */
	extern struct mutex dev_opp_list_lock;		extern struct mutex opp_table_lock;

	/*		/*
	* Internal data structure organization with the OPP layer library is as		* Internal data structure organization with the OPP layer library is as
	* follows:		* follows:
	* dev_opp_list (root)		* opp_tables (root)
	* \|- device 1 (represents voltage domain 1)		* \|- device 1 (represents voltage domain 1)
	* \| \|- opp 1 (availability, freq, voltage)		* \| \|- opp 1 (availability, freq, voltage)
	* \| \|- opp 2 ..		* \| \|- opp 2 ..
	@@ -40,18 +40,18 @@ extern struct mutex dev_opp_list_lock;
	* \|- device 2 (represents the next voltage domain)		* \|- device 2 (represents the next voltage domain)
	* ...		* ...
	* `- device m (represents mth voltage domain)		* `- device m (represents mth voltage domain)
	* device 1, 2.. are represented by dev_opp structure while each opp		* device 1, 2.. are represented by opp_table structure while each opp
	* is represented by the opp structure.		* is represented by the opp structure.
	*/		*/

	/**		/**
	* struct dev_pm_opp - Generic OPP description structure		* struct dev_pm_opp - Generic OPP description structure
	* @node: opp list node. The nodes are maintained throughout the lifetime		* @node: opp table node. The nodes are maintained throughout the lifetime
	* of boot. It is expected only an optimal set of OPPs are		* of boot. It is expected only an optimal set of OPPs are
	* added to the library by the SoC framework.		* added to the library by the SoC framework.
	* RCU usage: opp list is traversed with RCU locks. node		* RCU usage: opp table is traversed with RCU locks. node
	* modification is possible realtime, hence the modifications		* modification is possible realtime, hence the modifications
	* are protected by the dev_opp_list_lock for integrity.		* are protected by the opp_table_lock for integrity.
	* IMPORTANT: the opp nodes should be maintained in increasing		* IMPORTANT: the opp nodes should be maintained in increasing
	* order.		* order.
	* @available: true/false - marks if this OPP as available or not		* @available: true/false - marks if this OPP as available or not
	@@ -65,7 +65,7 @@ extern struct mutex dev_opp_list_lock;
	* @u_amp: Maximum current drawn by the device in microamperes		* @u_amp: Maximum current drawn by the device in microamperes
	* @clock_latency_ns: Latency (in nanoseconds) of switching to this OPP's		* @clock_latency_ns: Latency (in nanoseconds) of switching to this OPP's
	* frequency from any other OPP's frequency.		* frequency from any other OPP's frequency.
	* @dev_opp: points back to the device_opp struct this opp belongs to		* @opp_table: points back to the opp_table struct this opp belongs to
	* @rcu_head: RCU callback head used for deferred freeing		* @rcu_head: RCU callback head used for deferred freeing
	* @np: OPP's device node.		* @np: OPP's device node.
	* @dentry: debugfs dentry pointer (per opp)		* @dentry: debugfs dentry pointer (per opp)
	@@ -87,7 +87,7 @@ struct dev_pm_opp {
	unsigned long u_amp;		unsigned long u_amp;
	unsigned long clock_latency_ns;		unsigned long clock_latency_ns;

	struct device_opp *dev_opp;		struct opp_table *opp_table;
	struct rcu_head rcu_head;		struct rcu_head rcu_head;

	struct device_node *np;		struct device_node *np;
	@@ -98,16 +98,16 @@ struct dev_pm_opp {
	};		};

	/**		/**
	* struct device_list_opp - devices managed by 'struct device_opp'		* struct opp_device - devices managed by 'struct opp_table'
	* @node: list node		* @node: list node
	* @dev: device to which the struct object belongs		* @dev: device to which the struct object belongs
	* @rcu_head: RCU callback head used for deferred freeing		* @rcu_head: RCU callback head used for deferred freeing
	* @dentry: debugfs dentry pointer (per device)		* @dentry: debugfs dentry pointer (per device)
	*		*
	* This is an internal data structure maintaining the list of devices that are		* This is an internal data structure maintaining the devices that are managed
	* managed by 'struct device_opp'.		* by 'struct opp_table'.
	*/		*/
	struct device_list_opp {		struct opp_device {
	struct list_head node;		struct list_head node;
	const struct device *dev;		const struct device *dev;
	struct rcu_head rcu_head;		struct rcu_head rcu_head;
	@@ -118,16 +118,16 @@ struct device_list_opp {
	};		};

	/**		/**
	* struct device_opp - Device opp structure		* struct opp_table - Device opp structure
	* @node: list node - contains the devices with OPPs that		* @node: table node - contains the devices with OPPs that
	* have been registered. Nodes once added are not modified in this		* have been registered. Nodes once added are not modified in this
	* list.		* table.
	* RCU usage: nodes are not modified in the list of device_opp,		* RCU usage: nodes are not modified in the table of opp_table,
	* however addition is possible and is secured by dev_opp_list_lock		* however addition is possible and is secured by opp_table_lock
	* @srcu_head: notifier head to notify the OPP availability changes.		* @srcu_head: notifier head to notify the OPP availability changes.
	* @rcu_head: RCU callback head used for deferred freeing		* @rcu_head: RCU callback head used for deferred freeing
	* @dev_list: list of devices that share these OPPs		* @dev_list: list of devices that share these OPPs
	* @opp_list: list of opps		* @opp_list: table of opps
	* @np: struct device_node pointer for opp's DT node.		* @np: struct device_node pointer for opp's DT node.
	* @clock_latency_ns_max: Max clock latency in nanoseconds.		* @clock_latency_ns_max: Max clock latency in nanoseconds.
	* @shared_opp: OPP is shared between multiple devices.		* @shared_opp: OPP is shared between multiple devices.
	@@ -150,7 +150,7 @@ struct device_list_opp {
	* need to wait for the grace period of both of them before freeing any		* need to wait for the grace period of both of them before freeing any
	* resources. And so we have used kfree_rcu() from within call_srcu() handlers.		* resources. And so we have used kfree_rcu() from within call_srcu() handlers.
	*/		*/
	struct device_opp {		struct opp_table {
	struct list_head node;		struct list_head node;

	struct srcu_notifier_head srcu_head;		struct srcu_notifier_head srcu_head;
	@@ -180,30 +180,27 @@ struct device_opp {
	};		};

	/* Routines internal to opp core */		/* Routines internal to opp core */
	struct device_opp _find_device_opp(struct device dev);		struct opp_table _find_opp_table(struct device dev);
	struct device_list_opp _add_list_dev(const struct device dev,		struct opp_device _add_opp_dev(const struct device dev, struct opp_table *opp_table);
	struct device_opp *dev_opp);
	struct device_node _of_get_opp_desc_node(struct device dev);		struct device_node _of_get_opp_desc_node(struct device dev);

	#ifdef CONFIG_DEBUG_FS		#ifdef CONFIG_DEBUG_FS
	void opp_debug_remove_one(struct dev_pm_opp *opp);		void opp_debug_remove_one(struct dev_pm_opp *opp);
	int opp_debug_create_one(struct dev_pm_opp opp, struct device_opp dev_opp);		int opp_debug_create_one(struct dev_pm_opp opp, struct opp_table opp_table);
	int opp_debug_register(struct device_list_opp *list_dev,		int opp_debug_register(struct opp_device opp_dev, struct opp_table opp_table);
	struct device_opp *dev_opp);		void opp_debug_unregister(struct opp_device opp_dev, struct opp_table opp_table);
	void opp_debug_unregister(struct device_list_opp *list_dev,
	struct device_opp *dev_opp);
	#else		#else
	static inline void opp_debug_remove_one(struct dev_pm_opp *opp) {}		static inline void opp_debug_remove_one(struct dev_pm_opp *opp) {}

	static inline int opp_debug_create_one(struct dev_pm_opp *opp,		static inline int opp_debug_create_one(struct dev_pm_opp *opp,
	struct device_opp *dev_opp)		struct opp_table *opp_table)
	{ return 0; }		{ return 0; }
	static inline int opp_debug_register(struct device_list_opp *list_dev,		static inline int opp_debug_register(struct opp_device *opp_dev,
	struct device_opp *dev_opp)		struct opp_table *opp_table)
	{ return 0; }		{ return 0; }

	static inline void opp_debug_unregister(struct device_list_opp *list_dev,		static inline void opp_debug_unregister(struct opp_device *opp_dev,
	struct device_opp *dev_opp)		struct opp_table *opp_table)
	{ }		{ }
	#endif /* DEBUG_FS */		#endif /* DEBUG_FS */