[linux-block.git] / arch / arm / common / clkdev.c

/*
 *  arch/arm/common/clkdev.c
 *
 *  Copyright (C) 2008 Russell King.
 *
 * 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.
 *
 * 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 <asm/clkdev.h>
#include <mach/clkdev.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 precidence: dev+con > dev only > con only.
 */
static struct clk *clk_find(const char *dev_id, const char *con_id)
{
	struct clk_lookup *p;
	struct clk *clk = NULL;
	int match, best = 0;

	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 == 0)
			continue;

		if (match > best) {
			clk = p->clk;
			best = match;
		}
	}
	return clk;
}

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

	mutex_lock(&clocks_mutex);
	clk = clk_find(dev_id, con_id);
	if (clk && !__clk_get(clk))
		clk = NULL;
	mutex_unlock(&clocks_mutex);

	return clk ? clk : ERR_PTR(-ENOENT);
}
EXPORT_SYMBOL(clk_get);

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

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

#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];
};

struct clk_lookup *clkdev_alloc(struct clk *clk, const char *con_id,
	const char *dev_fmt, ...)
{
	struct clk_lookup_alloc *cla;

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

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

	if (dev_fmt) {
		va_list ap;

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

	return &cla->cl;
}
EXPORT_SYMBOL(clkdev_alloc);

/*
 * 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);
Commit	Line	Data
0318e693 RK	1	/*
	2	* arch/arm/common/clkdev.c
	3	*
	4	* Copyright (C) 2008 Russell King.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* Helper for the clk API to assist looking up a struct clk.
	11	*/
	12	#include <linux/module.h>
	13	#include <linux/kernel.h>
	14	#include <linux/device.h>
	15	#include <linux/list.h>
	16	#include <linux/errno.h>
	17	#include <linux/err.h>
	18	#include <linux/string.h>
	19	#include <linux/mutex.h>
	20
	21	#include <asm/clkdev.h>
	22	#include <mach/clkdev.h>
	23
	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
	34	* order of precidence: dev+con > dev only > con only.
	35	*/
0318e693 RK	36	static struct clk clk_find(const char dev_id, const char *con_id)
	37	{
	38	struct clk_lookup *p;
	39	struct clk *clk = NULL;
	40	int match, best = 0;
	41
	42	list_for_each_entry(p, &clocks, node) {
0318e693	43	match = 0;
409dc360 RK	44	if (p->dev_id) {
	45	if (!dev_id \|\| strcmp(p->dev_id, dev_id))
	46	continue;
	47	match += 2;
	48	}
	49	if (p->con_id) {
	50	if (!con_id \|\| strcmp(p->con_id, con_id))
	51	continue;
	52	match += 1;
	53	}
0318e693 RK	54	if (match == 0)
	55	continue;
	56
	57	if (match > best) {
	58	clk = p->clk;
	59	best = match;
	60	}
	61	}
	62	return clk;
	63	}
	64
	65	struct clk clk_get(struct device dev, const char *con_id)
	66	{
	67	const char *dev_id = dev ? dev_name(dev) : NULL;
	68	struct clk *clk;
	69
	70	mutex_lock(&clocks_mutex);
	71	clk = clk_find(dev_id, con_id);
	72	if (clk && !__clk_get(clk))
	73	clk = NULL;
	74	mutex_unlock(&clocks_mutex);
	75
	76	return clk ? clk : ERR_PTR(-ENOENT);
	77	}
	78	EXPORT_SYMBOL(clk_get);
	79
	80	void clk_put(struct clk *clk)
	81	{
	82	__clk_put(clk);
	83	}
	84	EXPORT_SYMBOL(clk_put);
	85
	86	void clkdev_add(struct clk_lookup *cl)
	87	{
	88	mutex_lock(&clocks_mutex);
	89	list_add_tail(&cl->node, &clocks);
	90	mutex_unlock(&clocks_mutex);
	91	}
	92	EXPORT_SYMBOL(clkdev_add);
	93
	94	#define MAX_DEV_ID 20
	95	#define MAX_CON_ID 16
	96
	97	struct clk_lookup_alloc {
	98	struct clk_lookup cl;
	99	char dev_id[MAX_DEV_ID];
	100	char con_id[MAX_CON_ID];
	101	};
	102
	103	struct clk_lookup clkdev_alloc(struct clk clk, const char *con_id,
	104	const char *dev_fmt, ...)
	105	{
	106	struct clk_lookup_alloc *cla;
	107
	108	cla = kzalloc(sizeof(*cla), GFP_KERNEL);
	109	if (!cla)
	110	return NULL;
	111
	112	cla->cl.clk = clk;
	113	if (con_id) {
	114	strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
	115	cla->cl.con_id = cla->con_id;
	116	}
	117
118	if (dev_fmt) {
119	va_list ap;
120
121	va_start(ap, dev_fmt);
122	vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
123	cla->cl.dev_id = cla->dev_id;
124	va_end(ap);
125	}
126
127	return &cla->cl;
128	}
129	EXPORT_SYMBOL(clkdev_alloc);
130
131	/*
132	* clkdev_drop - remove a clock dynamically allocated
133	*/
134	void clkdev_drop(struct clk_lookup *cl)
135	{
136	mutex_lock(&clocks_mutex);
137	list_del(&cl->node);
138	mutex_unlock(&clocks_mutex);
139	kfree(cl);
140	}
141	EXPORT_SYMBOL(clkdev_drop);