[deliverable/linux.git] / drivers / clk / clk-fixed-rate.c

/*
 * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
 * Copyright (C) 2011-2012 Mike Turquette, Linaro Ltd <mturquette@linaro.org>
 *
 * 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.
 *
 * Fixed rate clock implementation
 */

#include <linux/clk-provider.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/err.h>
#include <linux/of.h>

/*
 * DOC: basic fixed-rate clock that cannot gate
 *
 * Traits of this clock:
 * prepare - clk_(un)prepare only ensures parents are prepared
 * enable - clk_enable only ensures parents are enabled
 * rate - rate is always a fixed value.  No clk_set_rate support
 * parent - fixed parent.  No clk_set_parent support
 */

#define to_clk_fixed_rate(_hw) container_of(_hw, struct clk_fixed_rate, hw)

static unsigned long clk_fixed_rate_recalc_rate(struct clk_hw *hw,
		unsigned long parent_rate)
{
	return to_clk_fixed_rate(hw)->fixed_rate;
}

static unsigned long clk_fixed_rate_recalc_accuracy(struct clk_hw *hw,
		unsigned long parent_accuracy)
{
	return to_clk_fixed_rate(hw)->fixed_accuracy;
}

const struct clk_ops clk_fixed_rate_ops = {
	.recalc_rate = clk_fixed_rate_recalc_rate,
	.recalc_accuracy = clk_fixed_rate_recalc_accuracy,
};
EXPORT_SYMBOL_GPL(clk_fixed_rate_ops);

/**
 * clk_register_fixed_rate_with_accuracy - register fixed-rate clock with the
 *					   clock framework
 * @dev: device that is registering this clock
 * @name: name of this clock
 * @parent_name: name of clock's parent
 * @flags: framework-specific flags
 * @fixed_rate: non-adjustable clock rate
 * @fixed_accuracy: non-adjustable clock rate
 */
struct clk *clk_register_fixed_rate_with_accuracy(struct device *dev,
		const char *name, const char *parent_name, unsigned long flags,
		unsigned long fixed_rate, unsigned long fixed_accuracy)
{
	struct clk_fixed_rate *fixed;
	struct clk *clk;
	struct clk_init_data init;

	/* allocate fixed-rate clock */
	fixed = kzalloc(sizeof(*fixed), GFP_KERNEL);
	if (!fixed)
		return ERR_PTR(-ENOMEM);

	init.name = name;
	init.ops = &clk_fixed_rate_ops;
	init.flags = flags | CLK_IS_BASIC;
	init.parent_names = (parent_name ? &parent_name: NULL);
	init.num_parents = (parent_name ? 1 : 0);

	/* struct clk_fixed_rate assignments */
	fixed->fixed_rate = fixed_rate;
	fixed->fixed_accuracy = fixed_accuracy;
	fixed->hw.init = &init;

	/* register the clock */
	clk = clk_register(dev, &fixed->hw);
	if (IS_ERR(clk))
		kfree(fixed);

	return clk;
}
EXPORT_SYMBOL_GPL(clk_register_fixed_rate_with_accuracy);

/**
 * clk_register_fixed_rate - register fixed-rate clock with the clock framework
 * @dev: device that is registering this clock
 * @name: name of this clock
 * @parent_name: name of clock's parent
 * @flags: framework-specific flags
 * @fixed_rate: non-adjustable clock rate
 */
struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
		const char *parent_name, unsigned long flags,
		unsigned long fixed_rate)
{
	return clk_register_fixed_rate_with_accuracy(dev, name, parent_name,
						     flags, fixed_rate, 0);
}
EXPORT_SYMBOL_GPL(clk_register_fixed_rate);

#ifdef CONFIG_OF
/**
 * of_fixed_clk_setup() - Setup function for simple fixed rate clock
 */
void of_fixed_clk_setup(struct device_node *node)
{
	struct clk *clk;
	const char *clk_name = node->name;
	u32 rate;
	u32 accuracy = 0;

	if (of_property_read_u32(node, "clock-frequency", &rate))
		return;

	of_property_read_u32(node, "clock-accuracy", &accuracy);

	of_property_read_string(node, "clock-output-names", &clk_name);

	clk = clk_register_fixed_rate_with_accuracy(NULL, clk_name, NULL,
						    CLK_IS_ROOT, rate,
						    accuracy);
	if (!IS_ERR(clk))
		of_clk_add_provider(node, of_clk_src_simple_get, clk);
}
EXPORT_SYMBOL_GPL(of_fixed_clk_setup);
CLK_OF_DECLARE(fixed_clk, "fixed-clock", of_fixed_clk_setup);
#endif
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
	3	* Copyright (C) 2011-2012 Mike Turquette, Linaro Ltd <mturquette@linaro.org>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	* Fixed rate clock implementation
	10	*/
	11
	12	#include <linux/clk-provider.h>
	13	#include <linux/module.h>
	14	#include <linux/slab.h>
	15	#include <linux/io.h>
	16	#include <linux/err.h>
	17	#include <linux/of.h>
	18
	19	/*
	20	* DOC: basic fixed-rate clock that cannot gate
	21	*
	22	* Traits of this clock:
	23	* prepare - clk_(un)prepare only ensures parents are prepared
	24	* enable - clk_enable only ensures parents are enabled
	25	* rate - rate is always a fixed value. No clk_set_rate support
	26	* parent - fixed parent. No clk_set_parent support
	27	*/
	28
	29	#define to_clk_fixed_rate(_hw) container_of(_hw, struct clk_fixed_rate, hw)
	30
	31	static unsigned long clk_fixed_rate_recalc_rate(struct clk_hw *hw,
	32	unsigned long parent_rate)
	33	{
	34	return to_clk_fixed_rate(hw)->fixed_rate;
	35	}
	36
	37	static unsigned long clk_fixed_rate_recalc_accuracy(struct clk_hw *hw,
	38	unsigned long parent_accuracy)
	39	{
	40	return to_clk_fixed_rate(hw)->fixed_accuracy;
	41	}
	42
	43	const struct clk_ops clk_fixed_rate_ops = {
	44	.recalc_rate = clk_fixed_rate_recalc_rate,
	45	.recalc_accuracy = clk_fixed_rate_recalc_accuracy,
	46	};
	47	EXPORT_SYMBOL_GPL(clk_fixed_rate_ops);
	48
	49	/**
	50	* clk_register_fixed_rate_with_accuracy - register fixed-rate clock with the
	51	* clock framework
	52	* @dev: device that is registering this clock
	53	* @name: name of this clock
	54	* @parent_name: name of clock's parent
	55	* @flags: framework-specific flags
	56	* @fixed_rate: non-adjustable clock rate
	57	* @fixed_accuracy: non-adjustable clock rate
	58	*/
	59	struct clk clk_register_fixed_rate_with_accuracy(struct device dev,
	60	const char name, const char parent_name, unsigned long flags,
	61	unsigned long fixed_rate, unsigned long fixed_accuracy)
	62	{
	63	struct clk_fixed_rate *fixed;
	64	struct clk *clk;
	65	struct clk_init_data init;
	66
	67	/* allocate fixed-rate clock */
	68	fixed = kzalloc(sizeof(*fixed), GFP_KERNEL);
	69	if (!fixed)
	70	return ERR_PTR(-ENOMEM);
	71
	72	init.name = name;
	73	init.ops = &clk_fixed_rate_ops;
	74	init.flags = flags \| CLK_IS_BASIC;
	75	init.parent_names = (parent_name ? &parent_name: NULL);
	76	init.num_parents = (parent_name ? 1 : 0);
	77
	78	/* struct clk_fixed_rate assignments */
	79	fixed->fixed_rate = fixed_rate;
	80	fixed->fixed_accuracy = fixed_accuracy;
	81	fixed->hw.init = &init;
	82
	83	/* register the clock */
	84	clk = clk_register(dev, &fixed->hw);
	85	if (IS_ERR(clk))
	86	kfree(fixed);
	87
	88	return clk;
	89	}
	90	EXPORT_SYMBOL_GPL(clk_register_fixed_rate_with_accuracy);
	91
	92	/**
	93	* clk_register_fixed_rate - register fixed-rate clock with the clock framework
	94	* @dev: device that is registering this clock
	95	* @name: name of this clock
	96	* @parent_name: name of clock's parent
	97	* @flags: framework-specific flags
	98	* @fixed_rate: non-adjustable clock rate
	99	*/
	100	struct clk clk_register_fixed_rate(struct device dev, const char *name,
	101	const char *parent_name, unsigned long flags,
	102	unsigned long fixed_rate)
	103	{
	104	return clk_register_fixed_rate_with_accuracy(dev, name, parent_name,
	105	flags, fixed_rate, 0);
	106	}
	107	EXPORT_SYMBOL_GPL(clk_register_fixed_rate);
	108
	109	#ifdef CONFIG_OF
	110	/**
	111	* of_fixed_clk_setup() - Setup function for simple fixed rate clock
	112	*/
	113	void of_fixed_clk_setup(struct device_node *node)
	114	{
	115	struct clk *clk;
	116	const char *clk_name = node->name;
	117	u32 rate;
	118	u32 accuracy = 0;
	119
	120	if (of_property_read_u32(node, "clock-frequency", &rate))
	121	return;
	122
	123	of_property_read_u32(node, "clock-accuracy", &accuracy);
	124
	125	of_property_read_string(node, "clock-output-names", &clk_name);
	126
	127	clk = clk_register_fixed_rate_with_accuracy(NULL, clk_name, NULL,
	128	CLK_IS_ROOT, rate,
	129	accuracy);
	130	if (!IS_ERR(clk))
	131	of_clk_add_provider(node, of_clk_src_simple_get, clk);
	132	}
	133	EXPORT_SYMBOL_GPL(of_fixed_clk_setup);
	134	CLK_OF_DECLARE(fixed_clk, "fixed-clock", of_fixed_clk_setup);
	135	#endif