[mirror_ubuntu-focal-kernel.git] / drivers / clk / clkdev.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * drivers/clk/clkdev.c
 *
 *  Copyright (C) 2008 Russell King.
 *
 * Helper for the clk API to assist looking up a struct clk.
 */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/err.h>
#include <linux/string.h>
#include <linux/mutex.h>
#include <linux/clk.h>
#include <linux/clkdev.h>
#include <linux/clk-provider.h>
#include <linux/of.h>

#include "clk.h"

static LIST_HEAD(clocks);
static DEFINE_MUTEX(clocks_mutex);

/*
 * Find the correct struct clk for the device and connection ID.
 * We do slightly fuzzy matching here:
 *  An entry with a NULL ID is assumed to be a wildcard.
 *  If an entry has a device ID, it must match
 *  If an entry has a connection ID, it must match
 * Then we take the most specific entry - with the following
 * order of precedence: dev+con > dev only > con only.
 */
static struct clk_lookup *clk_find(const char *dev_id, const char *con_id)
{
	struct clk_lookup *p, *cl = NULL;
	int match, best_found = 0, best_possible = 0;

	if (dev_id)
		best_possible += 2;
	if (con_id)
		best_possible += 1;

	lockdep_assert_held(&clocks_mutex);

	list_for_each_entry(p, &clocks, node) {
		match = 0;
		if (p->dev_id) {
			if (!dev_id || strcmp(p->dev_id, dev_id))
				continue;
			match += 2;
		}
		if (p->con_id) {
			if (!con_id || strcmp(p->con_id, con_id))
				continue;
			match += 1;
		}

		if (match > best_found) {
			cl = p;
			if (match != best_possible)
				best_found = match;
			else
				break;
		}
	}
	return cl;
}

struct clk_hw *clk_find_hw(const char *dev_id, const char *con_id)
{
	struct clk_lookup *cl;
	struct clk_hw *hw = ERR_PTR(-ENOENT);

	mutex_lock(&clocks_mutex);
	cl = clk_find(dev_id, con_id);
	if (cl)
		hw = cl->clk_hw;
	mutex_unlock(&clocks_mutex);

	return hw;
}

static struct clk *__clk_get_sys(struct device *dev, const char *dev_id,
				 const char *con_id)
{
	struct clk_hw *hw = clk_find_hw(dev_id, con_id);

	return clk_hw_create_clk(dev, hw, dev_id, con_id);
}

struct clk *clk_get_sys(const char *dev_id, const char *con_id)
{
	return __clk_get_sys(NULL, dev_id, con_id);
}
EXPORT_SYMBOL(clk_get_sys);

struct clk *clk_get(struct device *dev, const char *con_id)
{
	const char *dev_id = dev ? dev_name(dev) : NULL;
	struct clk_hw *hw;

	if (dev && dev->of_node) {
		hw = of_clk_get_hw(dev->of_node, 0, con_id);
		if (!IS_ERR(hw) || PTR_ERR(hw) == -EPROBE_DEFER)
			return clk_hw_create_clk(dev, hw, dev_id, con_id);
	}

	return __clk_get_sys(dev, dev_id, con_id);
}
EXPORT_SYMBOL(clk_get);

void clk_put(struct clk *clk)
{
	__clk_put(clk);
}
EXPORT_SYMBOL(clk_put);

static void __clkdev_add(struct clk_lookup *cl)
{
	mutex_lock(&clocks_mutex);
	list_add_tail(&cl->node, &clocks);
	mutex_unlock(&clocks_mutex);
}

void clkdev_add(struct clk_lookup *cl)
{
	if (!cl->clk_hw)
		cl->clk_hw = __clk_get_hw(cl->clk);
	__clkdev_add(cl);
}
EXPORT_SYMBOL(clkdev_add);

void clkdev_add_table(struct clk_lookup *cl, size_t num)
{
	mutex_lock(&clocks_mutex);
	while (num--) {
		cl->clk_hw = __clk_get_hw(cl->clk);
		list_add_tail(&cl->node, &clocks);
		cl++;
	}
	mutex_unlock(&clocks_mutex);
}

#define MAX_DEV_ID	20
#define MAX_CON_ID	16

struct clk_lookup_alloc {
	struct clk_lookup cl;
	char	dev_id[MAX_DEV_ID];
	char	con_id[MAX_CON_ID];
};

static struct clk_lookup * __ref
vclkdev_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
	va_list ap)
{
	struct clk_lookup_alloc *cla;

	cla = kzalloc(sizeof(*cla), GFP_KERNEL);
	if (!cla)
		return NULL;

	cla->cl.clk_hw = hw;
	if (con_id) {
		strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
		cla->cl.con_id = cla->con_id;
	}

	if (dev_fmt) {
		vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
		cla->cl.dev_id = cla->dev_id;
	}

	return &cla->cl;
}

static struct clk_lookup *
vclkdev_create(struct clk_hw *hw, const char *con_id, const char *dev_fmt,
	va_list ap)
{
	struct clk_lookup *cl;

	cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
	if (cl)
		__clkdev_add(cl);

	return cl;
}

struct clk_lookup * __ref
clkdev_alloc(struct clk *clk, const char *con_id, const char *dev_fmt, ...)
{
	struct clk_lookup *cl;
	va_list ap;

	va_start(ap, dev_fmt);
	cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
	va_end(ap);

	return cl;
}
EXPORT_SYMBOL(clkdev_alloc);

struct clk_lookup *
clkdev_hw_alloc(struct clk_hw *hw, const char *con_id, const char *dev_fmt, ...)
{
	struct clk_lookup *cl;
	va_list ap;

	va_start(ap, dev_fmt);
	cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
	va_end(ap);

	return cl;
}
EXPORT_SYMBOL(clkdev_hw_alloc);

/**
 * clkdev_create - allocate and add a clkdev lookup structure
 * @clk: struct clk to associate with all clk_lookups
 * @con_id: connection ID string on device
 * @dev_fmt: format string describing device name
 *
 * Returns a clk_lookup structure, which can be later unregistered and
 * freed.
 */
struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
	const char *dev_fmt, ...)
{
	struct clk_lookup *cl;
	va_list ap;

	va_start(ap, dev_fmt);
	cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
	va_end(ap);

	return cl;
}
EXPORT_SYMBOL_GPL(clkdev_create);

/**
 * clkdev_hw_create - allocate and add a clkdev lookup structure
 * @hw: struct clk_hw to associate with all clk_lookups
 * @con_id: connection ID string on device
 * @dev_fmt: format string describing device name
 *
 * Returns a clk_lookup structure, which can be later unregistered and
 * freed.
 */
struct clk_lookup *clkdev_hw_create(struct clk_hw *hw, const char *con_id,
	const char *dev_fmt, ...)
{
	struct clk_lookup *cl;
	va_list ap;

	va_start(ap, dev_fmt);
	cl = vclkdev_create(hw, con_id, dev_fmt, ap);
	va_end(ap);

	return cl;
}
EXPORT_SYMBOL_GPL(clkdev_hw_create);

int clk_add_alias(const char *alias, const char *alias_dev_name,
	const char *con_id, struct device *dev)
{
	struct clk *r = clk_get(dev, con_id);
	struct clk_lookup *l;

	if (IS_ERR(r))
		return PTR_ERR(r);

	l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
			  alias_dev_name);
	clk_put(r);

	return l ? 0 : -ENODEV;
}
EXPORT_SYMBOL(clk_add_alias);

/*
 * clkdev_drop - remove a clock dynamically allocated
 */
void clkdev_drop(struct clk_lookup *cl)
{
	mutex_lock(&clocks_mutex);
	list_del(&cl->node);
	mutex_unlock(&clocks_mutex);
	kfree(cl);
}
EXPORT_SYMBOL(clkdev_drop);

static struct clk_lookup *__clk_register_clkdev(struct clk_hw *hw,
						const char *con_id,
						const char *dev_id, ...)
{
	struct clk_lookup *cl;
	va_list ap;

	va_start(ap, dev_id);
	cl = vclkdev_create(hw, con_id, dev_id, ap);
	va_end(ap);

	return cl;
}

static int do_clk_register_clkdev(struct clk_hw *hw,
	struct clk_lookup **cl, const char *con_id, const char *dev_id)
{
	if (IS_ERR(hw))
		return PTR_ERR(hw);
	/*
	 * Since dev_id can be NULL, and NULL is handled specially, we must
	 * pass it as either a NULL format string, or with "%s".
	 */
	if (dev_id)
		*cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
	else
		*cl = __clk_register_clkdev(hw, con_id, NULL);

	return *cl ? 0 : -ENOMEM;
}

/**
 * clk_register_clkdev - register one clock lookup for a struct clk
 * @clk: struct clk to associate with all clk_lookups
 * @con_id: connection ID string on device
 * @dev_id: string describing device name
 *
 * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 * clkdev.
 *
 * To make things easier for mass registration, we detect error clks
 * from a previous clk_register() call, and return the error code for
 * those.  This is to permit this function to be called immediately
 * after clk_register().
 */
int clk_register_clkdev(struct clk *clk, const char *con_id,
	const char *dev_id)
{
	struct clk_lookup *cl;

	if (IS_ERR(clk))
		return PTR_ERR(clk);

	return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,
					      dev_id);
}
EXPORT_SYMBOL(clk_register_clkdev);

/**
 * clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
 * @hw: struct clk_hw to associate with all clk_lookups
 * @con_id: connection ID string on device
 * @dev_id: format string describing device name
 *
 * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 * clkdev.
 *
 * To make things easier for mass registration, we detect error clk_hws
 * from a previous clk_hw_register_*() call, and return the error code for
 * those.  This is to permit this function to be called immediately
 * after clk_hw_register_*().
 */
int clk_hw_register_clkdev(struct clk_hw *hw, const char *con_id,
	const char *dev_id)
{
	struct clk_lookup *cl;

	return do_clk_register_clkdev(hw, &cl, con_id, dev_id);
}
EXPORT_SYMBOL(clk_hw_register_clkdev);

static void devm_clkdev_release(struct device *dev, void *res)
{
	clkdev_drop(*(struct clk_lookup **)res);
}

static int devm_clk_match_clkdev(struct device *dev, void *res, void *data)
{
	struct clk_lookup **l = res;

	return *l == data;
}

/**
 * devm_clk_release_clkdev - Resource managed clkdev lookup release
 * @dev: device this lookup is bound
 * @con_id: connection ID string on device
 * @dev_id: format string describing device name
 *
 * Drop the clkdev lookup created with devm_clk_hw_register_clkdev.
 * Normally this function will not need to be called and the resource
 * management code will ensure that the resource is freed.
 */
void devm_clk_release_clkdev(struct device *dev, const char *con_id,
			     const char *dev_id)
{
	struct clk_lookup *cl;
	int rval;

	mutex_lock(&clocks_mutex);
	cl = clk_find(dev_id, con_id);
	mutex_unlock(&clocks_mutex);

	WARN_ON(!cl);
	rval = devres_release(dev, devm_clkdev_release,
			      devm_clk_match_clkdev, cl);
	WARN_ON(rval);
}
EXPORT_SYMBOL(devm_clk_release_clkdev);

/**
 * devm_clk_hw_register_clkdev - managed clk lookup registration for clk_hw
 * @dev: device this lookup is bound
 * @hw: struct clk_hw to associate with all clk_lookups
 * @con_id: connection ID string on device
 * @dev_id: format string describing device name
 *
 * con_id or dev_id may be NULL as a wildcard, just as in the rest of
 * clkdev.
 *
 * To make things easier for mass registration, we detect error clk_hws
 * from a previous clk_hw_register_*() call, and return the error code for
 * those.  This is to permit this function to be called immediately
 * after clk_hw_register_*().
 */
int devm_clk_hw_register_clkdev(struct device *dev, struct clk_hw *hw,
				const char *con_id, const char *dev_id)
{
	int rval = -ENOMEM;
	struct clk_lookup **cl;

	cl = devres_alloc(devm_clkdev_release, sizeof(*cl), GFP_KERNEL);
	if (cl) {
		rval = do_clk_register_clkdev(hw, cl, con_id, dev_id);
		if (!rval)
			devres_add(dev, cl);
		else
			devres_free(cl);
	}
	return rval;
}
EXPORT_SYMBOL(devm_clk_hw_register_clkdev);
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
0318e693	2	/*
6d803ba7	3	* drivers/clk/clkdev.c
0318e693 RK	4	*
	5	* Copyright (C) 2008 Russell King.
	6	*
0318e693 RK	7	* Helper for the clk API to assist looking up a struct clk.
	8	*/
	9	#include <linux/module.h>
	10	#include <linux/kernel.h>
	11	#include <linux/device.h>
	12	#include <linux/list.h>
	13	#include <linux/errno.h>
	14	#include <linux/err.h>
	15	#include <linux/string.h>
	16	#include <linux/mutex.h>
c0c60c4b	17	#include <linux/clk.h>
6d803ba7	18	#include <linux/clkdev.h>
035a61c3	19	#include <linux/clk-provider.h>
766e6a4e	20	#include <linux/of.h>
0318e693	21
3a3d2b05 SN	22	#include "clk.h"
3a3d2b05 SN	23
0318e693 RK	24	static LIST_HEAD(clocks);
	25	static DEFINE_MUTEX(clocks_mutex);
	26
409dc360 RK	27	/*
	28	* Find the correct struct clk for the device and connection ID.
	29	* We do slightly fuzzy matching here:
	30	* An entry with a NULL ID is assumed to be a wildcard.
	31	* If an entry has a device ID, it must match
	32	* If an entry has a connection ID, it must match
	33	* Then we take the most specific entry - with the following
659431fc	34	* order of precedence: dev+con > dev only > con only.
409dc360	35	*/
e8bf8df9	36	static struct clk_lookup clk_find(const char dev_id, const char *con_id)
0318e693	37	{
e8bf8df9	38	struct clk_lookup p, cl = NULL;
67b50871 VK	39	int match, best_found = 0, best_possible = 0;
	40
	41	if (dev_id)
	42	best_possible += 2;
	43	if (con_id)
	44	best_possible += 1;
0318e693	45
5a7efdac SB	46	lockdep_assert_held(&clocks_mutex);
5a7efdac SB	47
0318e693	48	list_for_each_entry(p, &clocks, node) {
0318e693	49	match = 0;
409dc360 RK	50	if (p->dev_id) {
	51	if (!dev_id \|\| strcmp(p->dev_id, dev_id))
	52	continue;
	53	match += 2;
	54	}
	55	if (p->con_id) {
	56	if (!con_id \|\| strcmp(p->con_id, con_id))
	57	continue;
	58	match += 1;
	59	}
0318e693	60
67b50871	61	if (match > best_found) {
e8bf8df9	62	cl = p;
67b50871 VK	63	if (match != best_possible)
67b50871 VK	64	best_found = match;
e4bf5bec VK	65	else
e4bf5bec VK	66	break;
0318e693 RK	67	}
0318e693 RK	68	}
e8bf8df9	69	return cl;
0318e693 RK	70	}
0318e693 RK	71
dde4eff4	72	struct clk_hw clk_find_hw(const char dev_id, const char *con_id)
0318e693	73	{
e8bf8df9	74	struct clk_lookup *cl;
d1011cba	75	struct clk_hw *hw = ERR_PTR(-ENOENT);
0318e693 RK	76
0318e693 RK	77	mutex_lock(&clocks_mutex);
e8bf8df9	78	cl = clk_find(dev_id, con_id);
d1011cba SB	79	if (cl)
d1011cba SB	80	hw = cl->clk_hw;
0318e693 RK	81	mutex_unlock(&clocks_mutex);
0318e693 RK	82
d1011cba SB	83	return hw;
	84	}
	85
	86	static struct clk __clk_get_sys(struct device dev, const char *dev_id,
	87	const char *con_id)
	88	{
	89	struct clk_hw *hw = clk_find_hw(dev_id, con_id);
	90
	91	return clk_hw_create_clk(dev, hw, dev_id, con_id);
0318e693	92	}
efa85048 SB	93
	94	struct clk clk_get_sys(const char dev_id, const char *con_id)
	95	{
	96	return __clk_get_sys(NULL, dev_id, con_id);
	97	}
05fd8e73 SH	98	EXPORT_SYMBOL(clk_get_sys);
	99
	100	struct clk clk_get(struct device dev, const char *con_id)
	101	{
	102	const char *dev_id = dev ? dev_name(dev) : NULL;
4472287a	103	struct clk_hw *hw;
766e6a4e	104
53ccb22b	105	if (dev && dev->of_node) {
4472287a SB	106	hw = of_clk_get_hw(dev->of_node, 0, con_id);
4472287a SB	107	if (!IS_ERR(hw) \|\| PTR_ERR(hw) == -EPROBE_DEFER)
efa85048	108	return clk_hw_create_clk(dev, hw, dev_id, con_id);
766e6a4e	109	}
05fd8e73	110
efa85048	111	return __clk_get_sys(dev, dev_id, con_id);
05fd8e73	112	}
0318e693 RK	113	EXPORT_SYMBOL(clk_get);
	114
	115	void clk_put(struct clk *clk)
	116	{
	117	__clk_put(clk);
	118	}
	119	EXPORT_SYMBOL(clk_put);
	120
d5622a9c	121	static void __clkdev_add(struct clk_lookup *cl)
0318e693 RK	122	{
	123	mutex_lock(&clocks_mutex);
	124	list_add_tail(&cl->node, &clocks);
	125	mutex_unlock(&clocks_mutex);
	126	}
d5622a9c RK	127
	128	void clkdev_add(struct clk_lookup *cl)
	129	{
	130	if (!cl->clk_hw)
	131	cl->clk_hw = __clk_get_hw(cl->clk);
	132	__clkdev_add(cl);
	133	}
0318e693 RK	134	EXPORT_SYMBOL(clkdev_add);
0318e693 RK	135
fba3acd9	136	void clkdev_add_table(struct clk_lookup *cl, size_t num)
0a0300dc RK	137	{
	138	mutex_lock(&clocks_mutex);
	139	while (num--) {
d5622a9c	140	cl->clk_hw = __clk_get_hw(cl->clk);
0a0300dc RK	141	list_add_tail(&cl->node, &clocks);
	142	cl++;
	143	}
	144	mutex_unlock(&clocks_mutex);
	145	}
	146
0318e693 RK	147	#define MAX_DEV_ID 20
	148	#define MAX_CON_ID 16
	149
	150	struct clk_lookup_alloc {
	151	struct clk_lookup cl;
	152	char dev_id[MAX_DEV_ID];
	153	char con_id[MAX_CON_ID];
	154	};
	155
bd721ea7	156	static struct clk_lookup * __ref
d5622a9c	157	vclkdev_alloc(struct clk_hw hw, const char con_id, const char *dev_fmt,
e9d7f406	158	va_list ap)
0318e693 RK	159	{
	160	struct clk_lookup_alloc *cla;
	161
0d4e3d00	162	cla = kzalloc(sizeof(*cla), GFP_KERNEL);
0318e693 RK	163	if (!cla)
	164	return NULL;
	165
d5622a9c	166	cla->cl.clk_hw = hw;
0318e693 RK	167	if (con_id) {
	168	strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
	169	cla->cl.con_id = cla->con_id;
	170	}
	171
	172	if (dev_fmt) {
0318e693 RK	173	vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
0318e693 RK	174	cla->cl.dev_id = cla->dev_id;
0318e693 RK	175	}
	176
	177	return &cla->cl;
	178	}
e9d7f406	179
25689998 RK	180	static struct clk_lookup *
	181	vclkdev_create(struct clk_hw hw, const char con_id, const char *dev_fmt,
	182	va_list ap)
	183	{
	184	struct clk_lookup *cl;
	185
	186	cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
	187	if (cl)
	188	__clkdev_add(cl);
	189
	190	return cl;
	191	}
	192
bd721ea7	193	struct clk_lookup * __ref
e9d7f406 RK	194	clkdev_alloc(struct clk clk, const char con_id, const char *dev_fmt, ...)
	195	{
	196	struct clk_lookup *cl;
	197	va_list ap;
	198
	199	va_start(ap, dev_fmt);
d5622a9c	200	cl = vclkdev_alloc(__clk_get_hw(clk), con_id, dev_fmt, ap);
e9d7f406 RK	201	va_end(ap);
	202
	203	return cl;
	204	}
0318e693 RK	205	EXPORT_SYMBOL(clkdev_alloc);
0318e693 RK	206
e4f1b49b SB	207	struct clk_lookup *
	208	clkdev_hw_alloc(struct clk_hw hw, const char con_id, const char *dev_fmt, ...)
	209	{
	210	struct clk_lookup *cl;
	211	va_list ap;
	212
	213	va_start(ap, dev_fmt);
	214	cl = vclkdev_alloc(hw, con_id, dev_fmt, ap);
	215	va_end(ap);
	216
	217	return cl;
	218	}
	219	EXPORT_SYMBOL(clkdev_hw_alloc);
	220
25689998 RK	221	/**
	222	* clkdev_create - allocate and add a clkdev lookup structure
	223	* @clk: struct clk to associate with all clk_lookups
	224	* @con_id: connection ID string on device
	225	* @dev_fmt: format string describing device name
	226	*
	227	* Returns a clk_lookup structure, which can be later unregistered and
	228	* freed.
	229	*/
	230	struct clk_lookup clkdev_create(struct clk clk, const char *con_id,
	231	const char *dev_fmt, ...)
	232	{
	233	struct clk_lookup *cl;
	234	va_list ap;
	235
	236	va_start(ap, dev_fmt);
	237	cl = vclkdev_create(__clk_get_hw(clk), con_id, dev_fmt, ap);
	238	va_end(ap);
	239
	240	return cl;
	241	}
	242	EXPORT_SYMBOL_GPL(clkdev_create);
	243
e4f1b49b SB	244	/**
	245	* clkdev_hw_create - allocate and add a clkdev lookup structure
	246	* @hw: struct clk_hw to associate with all clk_lookups
	247	* @con_id: connection ID string on device
	248	* @dev_fmt: format string describing device name
	249	*
	250	* Returns a clk_lookup structure, which can be later unregistered and
	251	* freed.
	252	*/
	253	struct clk_lookup clkdev_hw_create(struct clk_hw hw, const char *con_id,
	254	const char *dev_fmt, ...)
	255	{
	256	struct clk_lookup *cl;
	257	va_list ap;
	258
	259	va_start(ap, dev_fmt);
	260	cl = vclkdev_create(hw, con_id, dev_fmt, ap);
	261	va_end(ap);
	262
	263	return cl;
	264	}
	265	EXPORT_SYMBOL_GPL(clkdev_hw_create);
	266
b3d8d7e8 RK	267	int clk_add_alias(const char alias, const char alias_dev_name,
b3d8d7e8 RK	268	const char con_id, struct device dev)
c0683039	269	{
b3d8d7e8	270	struct clk *r = clk_get(dev, con_id);
c0683039 TL	271	struct clk_lookup *l;
	272
	273	if (IS_ERR(r))
	274	return PTR_ERR(r);
	275
625faa6a RK	276	l = clkdev_create(r, alias, alias_dev_name ? "%s" : NULL,
625faa6a RK	277	alias_dev_name);
c0683039	278	clk_put(r);
25689998 RK	279
25689998 RK	280	return l ? 0 : -ENODEV;
c0683039 TL	281	}
	282	EXPORT_SYMBOL(clk_add_alias);
	283
0318e693 RK	284	/*
	285	* clkdev_drop - remove a clock dynamically allocated
	286	*/
	287	void clkdev_drop(struct clk_lookup *cl)
	288	{
	289	mutex_lock(&clocks_mutex);
	290	list_del(&cl->node);
	291	mutex_unlock(&clocks_mutex);
	292	kfree(cl);
	293	}
	294	EXPORT_SYMBOL(clkdev_drop);
e9d7f406	295
416dd13a KC	296	static struct clk_lookup __clk_register_clkdev(struct clk_hw hw,
	297	const char *con_id,
	298	const char *dev_id, ...)
	299	{
	300	struct clk_lookup *cl;
	301	va_list ap;
	302
	303	va_start(ap, dev_id);
	304	cl = vclkdev_create(hw, con_id, dev_id, ap);
	305	va_end(ap);
	306
	307	return cl;
	308	}
	309
3eee6c7d MV	310	static int do_clk_register_clkdev(struct clk_hw *hw,
	311	struct clk_lookup *cl, const char con_id, const char *dev_id)
	312	{
	313	if (IS_ERR(hw))
	314	return PTR_ERR(hw);
	315	/*
	316	* Since dev_id can be NULL, and NULL is handled specially, we must
	317	* pass it as either a NULL format string, or with "%s".
	318	*/
	319	if (dev_id)
	320	*cl = __clk_register_clkdev(hw, con_id, "%s", dev_id);
	321	else
	322	*cl = __clk_register_clkdev(hw, con_id, NULL);
	323
	324	return *cl ? 0 : -ENOMEM;
	325	}
	326
e9d7f406 RK	327	/**
	328	* clk_register_clkdev - register one clock lookup for a struct clk
	329	* @clk: struct clk to associate with all clk_lookups
	330	* @con_id: connection ID string on device
416dd13a	331	* @dev_id: string describing device name
e9d7f406 RK	332	*
	333	* con_id or dev_id may be NULL as a wildcard, just as in the rest of
	334	* clkdev.
	335	*
	336	* To make things easier for mass registration, we detect error clks
	337	* from a previous clk_register() call, and return the error code for
	338	* those. This is to permit this function to be called immediately
	339	* after clk_register().
	340	*/
	341	int clk_register_clkdev(struct clk clk, const char con_id,
416dd13a	342	const char *dev_id)
e9d7f406 RK	343	{
e9d7f406 RK	344	struct clk_lookup *cl;
e9d7f406 RK	345
	346	if (IS_ERR(clk))
	347	return PTR_ERR(clk);
	348
3eee6c7d MV	349	return do_clk_register_clkdev(__clk_get_hw(clk), &cl, con_id,
3eee6c7d MV	350	dev_id);
e9d7f406	351	}
a251361a	352	EXPORT_SYMBOL(clk_register_clkdev);
e4f1b49b SB	353
	354	/**
	355	* clk_hw_register_clkdev - register one clock lookup for a struct clk_hw
	356	* @hw: struct clk_hw to associate with all clk_lookups
	357	* @con_id: connection ID string on device
	358	* @dev_id: format string describing device name
	359	*
	360	* con_id or dev_id may be NULL as a wildcard, just as in the rest of
	361	* clkdev.
9388093d GU	362	*
	363	* To make things easier for mass registration, we detect error clk_hws
	364	* from a previous clk_hw_register_*() call, and return the error code for
	365	* those. This is to permit this function to be called immediately
	366	* after clk_hw_register_*().
e4f1b49b SB	367	*/
	368	int clk_hw_register_clkdev(struct clk_hw hw, const char con_id,
	369	const char *dev_id)
	370	{
	371	struct clk_lookup *cl;
	372
3eee6c7d MV	373	return do_clk_register_clkdev(hw, &cl, con_id, dev_id);
	374	}
	375	EXPORT_SYMBOL(clk_hw_register_clkdev);
9388093d	376
3eee6c7d MV	377	static void devm_clkdev_release(struct device dev, void res)
	378	{
	379	clkdev_drop((struct clk_lookup *)res);
	380	}
e4f1b49b	381
3eee6c7d MV	382	static int devm_clk_match_clkdev(struct device dev, void res, void *data)
	383	{
	384	struct clk_lookup **l = res;
e4f1b49b	385
3eee6c7d	386	return *l == data;
e4f1b49b	387	}
3eee6c7d MV	388
	389	/**
	390	* devm_clk_release_clkdev - Resource managed clkdev lookup release
	391	* @dev: device this lookup is bound
	392	* @con_id: connection ID string on device
	393	* @dev_id: format string describing device name
	394	*
	395	* Drop the clkdev lookup created with devm_clk_hw_register_clkdev.
	396	* Normally this function will not need to be called and the resource
	397	* management code will ensure that the resource is freed.
	398	*/
	399	void devm_clk_release_clkdev(struct device dev, const char con_id,
	400	const char *dev_id)
	401	{
	402	struct clk_lookup *cl;
	403	int rval;
	404
5a7efdac	405	mutex_lock(&clocks_mutex);
3eee6c7d	406	cl = clk_find(dev_id, con_id);
5a7efdac SB	407	mutex_unlock(&clocks_mutex);
5a7efdac SB	408
3eee6c7d MV	409	WARN_ON(!cl);
	410	rval = devres_release(dev, devm_clkdev_release,
	411	devm_clk_match_clkdev, cl);
	412	WARN_ON(rval);
	413	}
	414	EXPORT_SYMBOL(devm_clk_release_clkdev);
	415
	416	/**
	417	* devm_clk_hw_register_clkdev - managed clk lookup registration for clk_hw
	418	* @dev: device this lookup is bound
	419	* @hw: struct clk_hw to associate with all clk_lookups
	420	* @con_id: connection ID string on device
	421	* @dev_id: format string describing device name
	422	*
	423	* con_id or dev_id may be NULL as a wildcard, just as in the rest of
	424	* clkdev.
	425	*
	426	* To make things easier for mass registration, we detect error clk_hws
	427	* from a previous clk_hw_register_*() call, and return the error code for
	428	* those. This is to permit this function to be called immediately
	429	* after clk_hw_register_*().
	430	*/
	431	int devm_clk_hw_register_clkdev(struct device dev, struct clk_hw hw,
	432	const char con_id, const char dev_id)
	433	{
	434	int rval = -ENOMEM;
	435	struct clk_lookup **cl;
	436
	437	cl = devres_alloc(devm_clkdev_release, sizeof(*cl), GFP_KERNEL);
	438	if (cl) {
	439	rval = do_clk_register_clkdev(hw, cl, con_id, dev_id);
	440	if (!rval)
	441	devres_add(dev, cl);
	442	else
	443	devres_free(cl);
	444	}
	445	return rval;
	446	}
	447	EXPORT_SYMBOL(devm_clk_hw_register_clkdev);