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 #include <linux/platform_device.h>
19 
20 /*
21  * DOC: basic fixed-rate clock that cannot gate
22  *
23  * Traits of this clock:
24  * prepare - clk_(un)prepare only ensures parents are prepared
25  * enable - clk_enable only ensures parents are enabled
26  * rate - rate is always a fixed value.  No clk_set_rate support
27  * parent - fixed parent.  No clk_set_parent support
28  */
29 
clk_fixed_rate_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)30 static unsigned long clk_fixed_rate_recalc_rate(struct clk_hw *hw,
31 		unsigned long parent_rate)
32 {
33 	return to_clk_fixed_rate(hw)->fixed_rate;
34 }
35 
clk_fixed_rate_recalc_accuracy(struct clk_hw * hw,unsigned long parent_accuracy)36 static unsigned long clk_fixed_rate_recalc_accuracy(struct clk_hw *hw,
37 		unsigned long parent_accuracy)
38 {
39 	return to_clk_fixed_rate(hw)->fixed_accuracy;
40 }
41 
42 const struct clk_ops clk_fixed_rate_ops = {
43 	.recalc_rate = clk_fixed_rate_recalc_rate,
44 	.recalc_accuracy = clk_fixed_rate_recalc_accuracy,
45 };
46 EXPORT_SYMBOL_GPL(clk_fixed_rate_ops);
47 
48 /**
49  * clk_hw_register_fixed_rate_with_accuracy - register fixed-rate clock with
50  * the clock framework
51  * @dev: device that is registering this clock
52  * @name: name of this clock
53  * @parent_name: name of clock's parent
54  * @flags: framework-specific flags
55  * @fixed_rate: non-adjustable clock rate
56  * @fixed_accuracy: non-adjustable clock rate
57  */
clk_hw_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)58 struct clk_hw *clk_hw_register_fixed_rate_with_accuracy(struct device *dev,
59 		const char *name, const char *parent_name, unsigned long flags,
60 		unsigned long fixed_rate, unsigned long fixed_accuracy)
61 {
62 	struct clk_fixed_rate *fixed;
63 	struct clk_hw *hw;
64 	struct clk_init_data init;
65 	int ret;
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 	hw = &fixed->hw;
85 	ret = clk_hw_register(dev, hw);
86 	if (ret) {
87 		kfree(fixed);
88 		hw = ERR_PTR(ret);
89 	}
90 
91 	return hw;
92 }
93 EXPORT_SYMBOL_GPL(clk_hw_register_fixed_rate_with_accuracy);
94 
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)95 struct clk *clk_register_fixed_rate_with_accuracy(struct device *dev,
96 		const char *name, const char *parent_name, unsigned long flags,
97 		unsigned long fixed_rate, unsigned long fixed_accuracy)
98 {
99 	struct clk_hw *hw;
100 
101 	hw = clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name,
102 			flags, fixed_rate, fixed_accuracy);
103 	if (IS_ERR(hw))
104 		return ERR_CAST(hw);
105 	return hw->clk;
106 }
107 EXPORT_SYMBOL_GPL(clk_register_fixed_rate_with_accuracy);
108 
109 /**
110  * clk_hw_register_fixed_rate - register fixed-rate clock with the clock
111  * framework
112  * @dev: device that is registering this clock
113  * @name: name of this clock
114  * @parent_name: name of clock's parent
115  * @flags: framework-specific flags
116  * @fixed_rate: non-adjustable clock rate
117  */
clk_hw_register_fixed_rate(struct device * dev,const char * name,const char * parent_name,unsigned long flags,unsigned long fixed_rate)118 struct clk_hw *clk_hw_register_fixed_rate(struct device *dev, const char *name,
119 		const char *parent_name, unsigned long flags,
120 		unsigned long fixed_rate)
121 {
122 	return clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name,
123 						     flags, fixed_rate, 0);
124 }
125 EXPORT_SYMBOL_GPL(clk_hw_register_fixed_rate);
126 
clk_register_fixed_rate(struct device * dev,const char * name,const char * parent_name,unsigned long flags,unsigned long fixed_rate)127 struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
128 		const char *parent_name, unsigned long flags,
129 		unsigned long fixed_rate)
130 {
131 	return clk_register_fixed_rate_with_accuracy(dev, name, parent_name,
132 						     flags, fixed_rate, 0);
133 }
134 EXPORT_SYMBOL_GPL(clk_register_fixed_rate);
135 
clk_unregister_fixed_rate(struct clk * clk)136 void clk_unregister_fixed_rate(struct clk *clk)
137 {
138 	struct clk_hw *hw;
139 
140 	hw = __clk_get_hw(clk);
141 	if (!hw)
142 		return;
143 
144 	clk_unregister(clk);
145 	kfree(to_clk_fixed_rate(hw));
146 }
147 EXPORT_SYMBOL_GPL(clk_unregister_fixed_rate);
148 
clk_hw_unregister_fixed_rate(struct clk_hw * hw)149 void clk_hw_unregister_fixed_rate(struct clk_hw *hw)
150 {
151 	struct clk_fixed_rate *fixed;
152 
153 	fixed = to_clk_fixed_rate(hw);
154 
155 	clk_hw_unregister(hw);
156 	kfree(fixed);
157 }
158 EXPORT_SYMBOL_GPL(clk_hw_unregister_fixed_rate);
159 
160 #ifdef CONFIG_OF
_of_fixed_clk_setup(struct device_node * node)161 static struct clk *_of_fixed_clk_setup(struct device_node *node)
162 {
163 	struct clk *clk;
164 	const char *clk_name = node->name;
165 	u32 rate;
166 	u32 accuracy = 0;
167 	int ret;
168 
169 	if (of_property_read_u32(node, "clock-frequency", &rate))
170 		return ERR_PTR(-EIO);
171 
172 	of_property_read_u32(node, "clock-accuracy", &accuracy);
173 
174 	of_property_read_string(node, "clock-output-names", &clk_name);
175 
176 	clk = clk_register_fixed_rate_with_accuracy(NULL, clk_name, NULL,
177 						    0, rate, accuracy);
178 	if (IS_ERR(clk))
179 		return clk;
180 
181 	ret = of_clk_add_provider(node, of_clk_src_simple_get, clk);
182 	if (ret) {
183 		clk_unregister(clk);
184 		return ERR_PTR(ret);
185 	}
186 
187 	return clk;
188 }
189 
190 /**
191  * of_fixed_clk_setup() - Setup function for simple fixed rate clock
192  */
of_fixed_clk_setup(struct device_node * node)193 void __init of_fixed_clk_setup(struct device_node *node)
194 {
195 	_of_fixed_clk_setup(node);
196 }
197 CLK_OF_DECLARE(fixed_clk, "fixed-clock", of_fixed_clk_setup);
198 
of_fixed_clk_remove(struct platform_device * pdev)199 static int of_fixed_clk_remove(struct platform_device *pdev)
200 {
201 	struct clk *clk = platform_get_drvdata(pdev);
202 
203 	of_clk_del_provider(pdev->dev.of_node);
204 	clk_unregister_fixed_rate(clk);
205 
206 	return 0;
207 }
208 
of_fixed_clk_probe(struct platform_device * pdev)209 static int of_fixed_clk_probe(struct platform_device *pdev)
210 {
211 	struct clk *clk;
212 
213 	/*
214 	 * This function is not executed when of_fixed_clk_setup
215 	 * succeeded.
216 	 */
217 	clk = _of_fixed_clk_setup(pdev->dev.of_node);
218 	if (IS_ERR(clk))
219 		return PTR_ERR(clk);
220 
221 	platform_set_drvdata(pdev, clk);
222 
223 	return 0;
224 }
225 
226 static const struct of_device_id of_fixed_clk_ids[] = {
227 	{ .compatible = "fixed-clock" },
228 	{ }
229 };
230 MODULE_DEVICE_TABLE(of, of_fixed_clk_ids);
231 
232 static struct platform_driver of_fixed_clk_driver = {
233 	.driver = {
234 		.name = "of_fixed_clk",
235 		.of_match_table = of_fixed_clk_ids,
236 	},
237 	.probe = of_fixed_clk_probe,
238 	.remove = of_fixed_clk_remove,
239 };
240 builtin_platform_driver(of_fixed_clk_driver);
241 #endif
242