Commit 2c2709dc authored by Viresh Kumar's avatar Viresh Kumar Committed by Rafael J. Wysocki
Browse files

PM / OPP: Rename structures for clarity 



Stephen pointed out recently, that few structures always confuse him as
they aren't named properly. And this patch tries to address that:

Names are updated as:
- device_opp or dev_opp -> opp_table
- dev_opp_list -> opp_tables
- dev_opp_list_lock -> opp_table_lock
- device_list_opp -> opp_device (it was never a list, but a structure)
- list_dev -> opp_dev
- And similar changes in comments and function names as well.

This also fixes checkpatch warnings that were generated with this patch.

No functional changes.

Suggested-by: default avatarStephen Boyd <sboyd@codeaurora.org>
Signed-off-by: default avatarViresh Kumar <viresh.kumar@linaro.org>
Reviewed-by: default avatarStephen Boyd <sboyd@codeaurora.org>
Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
parent a5da6447

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 Diff line number Diff line
@@ -31,7 +31,7 @@ 
 * @table:	Cpufreq table returned back to caller

 *

 * Generate a cpufreq table for a provided device- this assumes that the

 * opp list is already initialized and ready for usage.

 * opp table is already initialized and ready for usage.

 *

 * This function allocates required memory for the cpufreq table. It is

 * expected that the caller does the required maintenance such as freeing
@@ -44,7 +44,7 @@ 
 * WARNING: It is  important for the callers to ensure refreshing their copy of

 * the table if any of the mentioned functions have been invoked in the interim.

 *

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

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

 * Since we just use the regular accessor functions to access the internal data

 * structures, we use RCU read lock inside this function. As a result, users of

 * this function DONOT need to use explicit locks for invoking.
@@ -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 */

int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)

{

	struct device_list_opp *list_dev;

	struct device_opp *dev_opp;

	struct opp_device *opp_dev;

	struct opp_table *opp_table;

	struct device *dev;

	int cpu, ret = 0;



	mutex_lock(&dev_opp_list_lock);

	mutex_lock(&opp_table_lock);



	dev_opp = _find_device_opp(cpu_dev);

	if (IS_ERR(dev_opp)) {

	opp_table = _find_opp_table(cpu_dev);

	if (IS_ERR(opp_table)) {

		ret = -EINVAL;

		goto unlock;

	}
@@ -146,15 +146,15 @@ int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask) 
			continue;

		}



		list_dev = _add_list_dev(dev, dev_opp);

		if (!list_dev) {

			dev_err(dev, "%s: failed to add list-dev for cpu%d device\n",

		opp_dev = _add_opp_dev(dev, opp_table);

		if (!opp_dev) {

			dev_err(dev, "%s: failed to add opp-dev for cpu%d device\n",

				__func__, cpu);

			continue;

		}

	}

unlock:

	mutex_unlock(&dev_opp_list_lock);

	mutex_unlock(&opp_table_lock);



	return ret;

}

drivers/base/power/opp/debugfs.c

+42 −43
Original line number Diff line number Diff line
@@ -34,9 +34,9 @@ void opp_debug_remove_one(struct dev_pm_opp *opp) 
	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;

	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;

}



static int device_opp_debug_create_dir(struct device_list_opp *list_dev,

				       struct device_opp *dev_opp)

static int opp_list_debug_create_dir(struct opp_device *opp_dev,

				     struct opp_table *opp_table)

{

	const struct device *dev = list_dev->dev;

	const struct device *dev = opp_dev->dev;

	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 */

	d = debugfs_create_dir(dev_opp->dentry_name, rootdir);

	d = debugfs_create_dir(opp_table->dentry_name, rootdir);

	if (!d) {

		dev_err(dev, "%s: Failed to create debugfs dir\n", __func__);

		return -ENOMEM;

	}



	list_dev->dentry = d;

	dev_opp->dentry = d;

	opp_dev->dentry = d;

	opp_table->dentry = d;



	return 0;

}



static int device_opp_debug_create_link(struct device_list_opp *list_dev,

					struct device_opp *dev_opp)

static int opp_list_debug_create_link(struct opp_device *opp_dev,

				      struct opp_table *opp_table)

{

	const struct device *dev = list_dev->dev;

	const struct device *dev = opp_dev->dev;

	char name[NAME_MAX];

	struct dentry *d;



	opp_set_dev_name(list_dev->dev, name);

	opp_set_dev_name(opp_dev->dev, name);



	/* 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) {

		dev_err(dev, "%s: Failed to create link\n", __func__);

		return -ENOMEM;

	}



	list_dev->dentry = d;

	opp_dev->dentry = d;



	return 0;

}



/**

 * opp_debug_register - add a device opp node to the debugfs 'opp' directory

 * @list_dev: list-dev pointer for device

 * @dev_opp: the device-opp being added

 * @opp_dev: opp-dev pointer for device

 * @opp_table: the device-opp being added

 *

 * 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
@@ -136,73 +136,72 @@ static int device_opp_debug_create_link(struct device_list_opp *list_dev, 
 *

 * Return: 0 on success, otherwise negative error.

 */

int opp_debug_register(struct device_list_opp *list_dev,

		       struct device_opp *dev_opp)

int opp_debug_register(struct opp_device *opp_dev, struct opp_table *opp_table)

{

	if (!rootdir) {

		pr_debug("%s: Uninitialized rootdir\n", __func__);

		return -EINVAL;

	}



	if (dev_opp->dentry)

		return device_opp_debug_create_link(list_dev, dev_opp);

	if (opp_table->dentry)

		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,

			       struct device_opp *dev_opp)

static void opp_migrate_dentry(struct opp_device *opp_dev,

			       struct opp_table *opp_table)

{

	struct device_list_opp *new_dev;

	struct opp_device *new_dev;

	const struct device *dev;

	struct dentry *dentry;



	/* Look for next list-dev */

	list_for_each_entry(new_dev, &dev_opp->dev_list, node)

		if (new_dev != list_dev)

	/* Look for next opp-dev */

	list_for_each_entry(new_dev, &opp_table->dev_list, node)

		if (new_dev != opp_dev)

			break;



	/* new_dev is guaranteed to be valid here */

	dev = new_dev->dev;

	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,

				dev_opp->dentry_name);

	dentry = debugfs_rename(rootdir, opp_dev->dentry, rootdir,

				opp_table->dentry_name);

	if (!dentry) {

		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;

	}



	new_dev->dentry = dentry;

	dev_opp->dentry = dentry;

	opp_table->dentry = dentry;

}



/**

 * opp_debug_unregister - remove a device opp node from debugfs opp directory

 * @list_dev: list-dev pointer for device

 * @dev_opp: the device-opp being removed

 * @opp_dev: opp-dev pointer for device

 * @opp_table: the device-opp being removed

 *

 * Dynamically removes device specific directory from debugfs 'opp' directory.

 */

void opp_debug_unregister(struct device_list_opp *list_dev,

			  struct device_opp *dev_opp)

void opp_debug_unregister(struct opp_device *opp_dev,

			  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 */

		if (!list_is_singular(&dev_opp->dev_list)) {

			opp_migrate_dentry(list_dev, dev_opp);

		if (!list_is_singular(&opp_table->dev_list)) {

			opp_migrate_dentry(opp_dev, opp_table);

			goto out;

		}

		dev_opp->dentry = NULL;

		opp_table->dentry = NULL;

	}



	debugfs_remove_recursive(list_dev->dentry);

	debugfs_remove_recursive(opp_dev->dentry);



out:

	list_dev->dentry = NULL;

	opp_dev->dentry = NULL;

}



static int __init opp_debug_init(void)

drivers/base/power/opp/opp.h

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



/* 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

 * follows:

 * dev_opp_list (root)

 * opp_tables (root)

 *	|- device 1 (represents voltage domain 1)

 *	|	|- opp 1 (availability, freq, voltage)

 *	|	|- opp 2 ..
@@ -40,18 +40,18 @@ extern struct mutex dev_opp_list_lock; 
 *	|- device 2 (represents the next voltage domain)

 *	...

 *	`- device m (represents mth voltage domain)

 * device 1, 2.. are represented by dev_opp structure while each opp

 * device 1, 2.. are represented by opp_table structure while each opp

 * is represented by the opp 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

 *		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

 *		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

 *		order.

 * @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

 * @clock_latency_ns: Latency (in nanoseconds) of switching to this OPP's

 *		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

 * @np:		OPP's device node.

 * @dentry:	debugfs dentry pointer (per opp)
@@ -87,7 +87,7 @@ struct dev_pm_opp { 
	unsigned long u_amp;

	unsigned long clock_latency_ns;



	struct device_opp *dev_opp;

	struct opp_table *opp_table;

	struct rcu_head rcu_head;



	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

 * @dev:	device to which the struct object belongs

 * @rcu_head:	RCU callback head used for deferred freeing

 * @dentry:	debugfs dentry pointer (per device)

 *

 * This is an internal data structure maintaining the list of devices that are

 * managed by 'struct device_opp'.

 * This is an internal data structure maintaining the devices that are managed

 * by 'struct opp_table'.

 */

struct device_list_opp {

struct opp_device {

	struct list_head node;

	const struct device *dev;

	struct rcu_head rcu_head;
@@ -118,16 +118,16 @@ struct device_list_opp { 
};



/**

 * struct device_opp - Device opp structure

 * @node:	list node - contains the devices with OPPs that

 * struct opp_table - Device opp structure

 * @node:	table node - contains the devices with OPPs that

 *		have been registered. Nodes once added are not modified in this

 *		list.

 *		RCU usage: nodes are not modified in the list of device_opp,

 *		however addition is possible and is secured by dev_opp_list_lock

 *		table.

 *		RCU usage: nodes are not modified in the table of opp_table,

 *		however addition is possible and is secured by opp_table_lock

 * @srcu_head:	notifier head to notify the OPP availability changes.

 * @rcu_head:	RCU callback head used for deferred freeing

 * @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.

 * @clock_latency_ns_max: Max clock latency in nanoseconds.

 * @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

 * resources. And so we have used kfree_rcu() from within call_srcu() handlers.

 */

struct device_opp {

struct opp_table {

	struct list_head node;



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



/* Routines internal to opp core */

struct device_opp *_find_device_opp(struct device *dev);

struct device_list_opp *_add_list_dev(const struct device *dev,

				      struct device_opp *dev_opp);

struct opp_table *_find_opp_table(struct device *dev);

struct opp_device *_add_opp_dev(const struct device *dev, struct opp_table *opp_table);

struct device_node *_of_get_opp_desc_node(struct device *dev);



#ifdef CONFIG_DEBUG_FS

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_register(struct device_list_opp *list_dev,

		       struct device_opp *dev_opp);

void opp_debug_unregister(struct device_list_opp *list_dev,

			  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 opp_device *opp_dev, struct opp_table *opp_table);

void opp_debug_unregister(struct opp_device *opp_dev, struct opp_table *opp_table);

#else

static inline void opp_debug_remove_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; }

static inline int opp_debug_register(struct device_list_opp *list_dev,

				     struct device_opp *dev_opp)

static inline int opp_debug_register(struct opp_device *opp_dev,

				     struct opp_table *opp_table)

{ return 0; }



static inline void opp_debug_unregister(struct device_list_opp *list_dev,

					struct device_opp *dev_opp)

static inline void opp_debug_unregister(struct opp_device *opp_dev,

					struct opp_table *opp_table)

{ }

#endif		/* DEBUG_FS */

CRA Git | Maintained and supported by SUSTech CRA and CCSE