]>
git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - arch/arm/plat-mxc/clock.c
1aa86fd60d711a2ba7c70200fff77253cf1e1ed0
2 * Based on arch/arm/plat-omap/clock.c
4 * Copyright (C) 2004 - 2005 Nokia corporation
5 * Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
6 * Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
7 * Copyright 2007 Freescale Semiconductor, Inc. All Rights Reserved.
8 * Copyright 2008 Juergen Beisert, kernel@pengutronix.de
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2
13 * of the License, or (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
27 #include <linux/clk.h>
28 #include <linux/err.h>
29 #include <linux/errno.h>
30 #include <linux/init.h>
32 #include <linux/kernel.h>
33 #include <linux/list.h>
34 #include <linux/module.h>
35 #include <linux/mutex.h>
36 #include <linux/platform_device.h>
37 #include <linux/proc_fs.h>
38 #include <linux/semaphore.h>
39 #include <linux/string.h>
40 #include <linux/version.h>
42 #include <asm/arch/clock.h>
44 static LIST_HEAD(clocks
);
45 static DEFINE_MUTEX(clocks_mutex
);
47 /*-------------------------------------------------------------------------
48 * Standard clock functions defined in include/linux/clk.h
49 *-------------------------------------------------------------------------*/
52 * Retrieve a clock by name.
54 * Note that we first try to use device id on the bus
55 * and clock name. If this fails, we try to use "<name>.<id>". If this fails,
56 * we try to use clock name only.
57 * The reference count to the clock's module owner ref count is incremented.
59 struct clk
*clk_get(struct device
*dev
, const char *id
)
61 struct clk
*p
, *clk
= ERR_PTR(-ENOENT
);
68 if (dev
== NULL
|| dev
->bus
!= &platform_bus_type
)
71 idno
= to_platform_device(dev
)->id
;
73 mutex_lock(&clocks_mutex
);
75 list_for_each_entry(p
, &clocks
, node
) {
77 strcmp(id
, p
->name
) == 0 && try_module_get(p
->owner
)) {
83 str
= strrchr(id
, '.');
87 idno
= simple_strtol(str
, NULL
, 10);
88 list_for_each_entry(p
, &clocks
, node
) {
90 strlen(p
->name
) == cnt
&&
91 strncmp(id
, p
->name
, cnt
) == 0 &&
92 try_module_get(p
->owner
)) {
99 list_for_each_entry(p
, &clocks
, node
) {
100 if (strcmp(id
, p
->name
) == 0 && try_module_get(p
->owner
)) {
106 printk(KERN_WARNING
"clk: Unable to get requested clock: %s\n", id
);
109 mutex_unlock(&clocks_mutex
);
113 EXPORT_SYMBOL(clk_get
);
115 static void __clk_disable(struct clk
*clk
)
117 if (clk
== NULL
|| IS_ERR(clk
))
120 __clk_disable(clk
->parent
);
121 __clk_disable(clk
->secondary
);
123 if (!(--clk
->usecount
) && clk
->disable
)
127 static int __clk_enable(struct clk
*clk
)
129 if (clk
== NULL
|| IS_ERR(clk
))
132 __clk_enable(clk
->parent
);
133 __clk_enable(clk
->secondary
);
135 if (clk
->usecount
++ == 0 && clk
->enable
)
141 /* This function increments the reference count on the clock and enables the
142 * clock if not already enabled. The parent clock tree is recursively enabled
144 int clk_enable(struct clk
*clk
)
148 if (clk
== NULL
|| IS_ERR(clk
))
151 mutex_lock(&clocks_mutex
);
152 ret
= __clk_enable(clk
);
153 mutex_unlock(&clocks_mutex
);
157 EXPORT_SYMBOL(clk_enable
);
159 /* This function decrements the reference count on the clock and disables
160 * the clock when reference count is 0. The parent clock tree is
161 * recursively disabled
163 void clk_disable(struct clk
*clk
)
165 if (clk
== NULL
|| IS_ERR(clk
))
168 mutex_lock(&clocks_mutex
);
170 mutex_unlock(&clocks_mutex
);
172 EXPORT_SYMBOL(clk_disable
);
174 /* Retrieve the *current* clock rate. If the clock itself
175 * does not provide a special calculation routine, ask
176 * its parent and so on, until one is able to return
179 unsigned long clk_get_rate(struct clk
*clk
)
181 if (clk
== NULL
|| IS_ERR(clk
))
185 return clk
->get_rate(clk
);
187 return clk_get_rate(clk
->parent
);
189 EXPORT_SYMBOL(clk_get_rate
);
191 /* Decrement the clock's module reference count */
192 void clk_put(struct clk
*clk
)
194 if (clk
&& !IS_ERR(clk
))
195 module_put(clk
->owner
);
197 EXPORT_SYMBOL(clk_put
);
199 /* Round the requested clock rate to the nearest supported
200 * rate that is less than or equal to the requested rate.
201 * This is dependent on the clock's current parent.
203 long clk_round_rate(struct clk
*clk
, unsigned long rate
)
205 if (clk
== NULL
|| IS_ERR(clk
) || !clk
->round_rate
)
208 return clk
->round_rate(clk
, rate
);
210 EXPORT_SYMBOL(clk_round_rate
);
212 /* Set the clock to the requested clock rate. The rate must
213 * match a supported rate exactly based on what clk_round_rate returns
215 int clk_set_rate(struct clk
*clk
, unsigned long rate
)
219 if (clk
== NULL
|| IS_ERR(clk
) || clk
->set_rate
== NULL
|| rate
== 0)
222 mutex_lock(&clocks_mutex
);
223 ret
= clk
->set_rate(clk
, rate
);
224 mutex_unlock(&clocks_mutex
);
228 EXPORT_SYMBOL(clk_set_rate
);
230 /* Set the clock's parent to another clock source */
231 int clk_set_parent(struct clk
*clk
, struct clk
*parent
)
235 if (clk
== NULL
|| IS_ERR(clk
) || parent
== NULL
||
236 IS_ERR(parent
) || clk
->set_parent
== NULL
)
239 mutex_lock(&clocks_mutex
);
240 ret
= clk
->set_parent(clk
, parent
);
242 clk
->parent
= parent
;
243 mutex_unlock(&clocks_mutex
);
247 EXPORT_SYMBOL(clk_set_parent
);
249 /* Retrieve the clock's parent clock source */
250 struct clk
*clk_get_parent(struct clk
*clk
)
252 struct clk
*ret
= NULL
;
254 if (clk
== NULL
|| IS_ERR(clk
))
259 EXPORT_SYMBOL(clk_get_parent
);
262 * Add a new clock to the clock tree.
264 int clk_register(struct clk
*clk
)
266 if (clk
== NULL
|| IS_ERR(clk
))
269 mutex_lock(&clocks_mutex
);
270 list_add(&clk
->node
, &clocks
);
271 mutex_unlock(&clocks_mutex
);
275 EXPORT_SYMBOL(clk_register
);
277 /* Remove a clock from the clock tree */
278 void clk_unregister(struct clk
*clk
)
280 if (clk
== NULL
|| IS_ERR(clk
))
283 mutex_lock(&clocks_mutex
);
284 list_del(&clk
->node
);
285 mutex_unlock(&clocks_mutex
);
287 EXPORT_SYMBOL(clk_unregister
);
289 #ifdef CONFIG_PROC_FS
290 static int mxc_clock_read_proc(char *page
, char **start
, off_t off
,
291 int count
, int *eof
, void *data
)
297 list_for_each_entry(clkp
, &clocks
, node
) {
298 p
+= sprintf(p
, "%s-%d:\t\t%lu, %d", clkp
->name
, clkp
->id
,
299 clk_get_rate(clkp
), clkp
->usecount
);
301 p
+= sprintf(p
, ", %s-%d\n", clkp
->parent
->name
,
304 p
+= sprintf(p
, "\n");
307 len
= (p
- page
) - off
;
311 *eof
= (len
<= count
) ? 1 : 0;
317 static int __init
mxc_setup_proc_entry(void)
319 struct proc_dir_entry
*res
;
321 res
= create_proc_read_entry("cpu/clocks", 0, NULL
,
322 mxc_clock_read_proc
, NULL
);
324 printk(KERN_ERR
"Failed to create proc/cpu/clocks\n");
330 late_initcall(mxc_setup_proc_entry
);