1 /* arch/arm/mach-msm/clock.c
3 * Copyright (C) 2007 Google, Inc.
4 * Copyright (c) 2007-2010, Code Aurora Forum. All rights reserved.
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/list.h>
21 #include <linux/err.h>
22 #include <linux/clk.h>
23 #include <linux/spinlock.h>
24 #include <linux/debugfs.h>
25 #include <linux/ctype.h>
26 #include <linux/pm_qos_params.h>
30 #include "proc_comm.h"
31 #include "clock-7x30.h"
33 static DEFINE_MUTEX(clocks_mutex
);
34 static DEFINE_SPINLOCK(clocks_lock
);
35 static LIST_HEAD(clocks
);
36 struct clk
*msm_clocks
;
37 unsigned msm_num_clocks
;
40 * Bitmap of enabled clocks, excluding ACPU which is always
43 static DECLARE_BITMAP(clock_map_enabled
, NR_CLKS
);
44 static DEFINE_SPINLOCK(clock_map_lock
);
47 * Standard clock functions defined in include/linux/clk.h
49 struct clk
*clk_get(struct device
*dev
, const char *id
)
53 mutex_lock(&clocks_mutex
);
55 list_for_each_entry(clk
, &clocks
, list
)
56 if (!strcmp(id
, clk
->name
) && clk
->dev
== dev
)
59 list_for_each_entry(clk
, &clocks
, list
)
60 if (!strcmp(id
, clk
->name
) && clk
->dev
== NULL
)
63 clk
= ERR_PTR(-ENOENT
);
65 mutex_unlock(&clocks_mutex
);
68 EXPORT_SYMBOL(clk_get
);
70 void clk_put(struct clk
*clk
)
73 EXPORT_SYMBOL(clk_put
);
75 int clk_enable(struct clk
*clk
)
78 spin_lock_irqsave(&clocks_lock
, flags
);
80 if (clk
->count
== 1) {
81 clk
->ops
->enable(clk
->id
);
82 spin_lock(&clock_map_lock
);
83 clock_map_enabled
[BIT_WORD(clk
->id
)] |= BIT_MASK(clk
->id
);
84 spin_unlock(&clock_map_lock
);
86 spin_unlock_irqrestore(&clocks_lock
, flags
);
89 EXPORT_SYMBOL(clk_enable
);
91 void clk_disable(struct clk
*clk
)
94 spin_lock_irqsave(&clocks_lock
, flags
);
95 BUG_ON(clk
->count
== 0);
97 if (clk
->count
== 0) {
98 clk
->ops
->disable(clk
->id
);
99 spin_lock(&clock_map_lock
);
100 clock_map_enabled
[BIT_WORD(clk
->id
)] &= ~BIT_MASK(clk
->id
);
101 spin_unlock(&clock_map_lock
);
103 spin_unlock_irqrestore(&clocks_lock
, flags
);
105 EXPORT_SYMBOL(clk_disable
);
107 int clk_reset(struct clk
*clk
, enum clk_reset_action action
)
109 if (!clk
->ops
->reset
)
110 clk
->ops
->reset
= &pc_clk_reset
;
111 return clk
->ops
->reset(clk
->remote_id
, action
);
113 EXPORT_SYMBOL(clk_reset
);
115 unsigned long clk_get_rate(struct clk
*clk
)
117 return clk
->ops
->get_rate(clk
->id
);
119 EXPORT_SYMBOL(clk_get_rate
);
121 int clk_set_rate(struct clk
*clk
, unsigned long rate
)
123 return clk
->ops
->set_rate(clk
->id
, rate
);
125 EXPORT_SYMBOL(clk_set_rate
);
127 long clk_round_rate(struct clk
*clk
, unsigned long rate
)
129 return clk
->ops
->round_rate(clk
->id
, rate
);
131 EXPORT_SYMBOL(clk_round_rate
);
133 int clk_set_min_rate(struct clk
*clk
, unsigned long rate
)
135 return clk
->ops
->set_min_rate(clk
->id
, rate
);
137 EXPORT_SYMBOL(clk_set_min_rate
);
139 int clk_set_max_rate(struct clk
*clk
, unsigned long rate
)
141 return clk
->ops
->set_max_rate(clk
->id
, rate
);
143 EXPORT_SYMBOL(clk_set_max_rate
);
145 int clk_set_parent(struct clk
*clk
, struct clk
*parent
)
149 EXPORT_SYMBOL(clk_set_parent
);
151 struct clk
*clk_get_parent(struct clk
*clk
)
153 return ERR_PTR(-ENOSYS
);
155 EXPORT_SYMBOL(clk_get_parent
);
157 int clk_set_flags(struct clk
*clk
, unsigned long flags
)
159 if (clk
== NULL
|| IS_ERR(clk
))
161 return clk
->ops
->set_flags(clk
->id
, flags
);
163 EXPORT_SYMBOL(clk_set_flags
);
165 /* EBI1 is the only shared clock that several clients want to vote on as of
166 * this commit. If this changes in the future, then it might be better to
167 * make clk_min_rate handle the voting or make ebi1_clk_set_min_rate more
168 * generic to support different clocks.
170 static struct clk
*ebi1_clk
;
172 static void __init
set_clock_ops(struct clk
*clk
)
175 clk
->ops
= &clk_ops_pcom
;
176 clk
->id
= clk
->remote_id
;
180 void __init
msm_clock_init(struct clk
*clock_tbl
, unsigned num_clocks
)
184 spin_lock_init(&clocks_lock
);
185 mutex_lock(&clocks_mutex
);
186 msm_clocks
= clock_tbl
;
187 msm_num_clocks
= num_clocks
;
188 for (n
= 0; n
< msm_num_clocks
; n
++) {
189 set_clock_ops(&msm_clocks
[n
]);
190 list_add_tail(&msm_clocks
[n
].list
, &clocks
);
192 mutex_unlock(&clocks_mutex
);
194 ebi1_clk
= clk_get(NULL
, "ebi1_clk");
195 BUG_ON(ebi1_clk
== NULL
);
199 #if defined(CONFIG_DEBUG_FS)
200 static struct clk
*msm_clock_get_nth(unsigned index
)
202 if (index
< msm_num_clocks
)
203 return msm_clocks
+ index
;
208 static int clock_debug_rate_set(void *data
, u64 val
)
210 struct clk
*clock
= data
;
213 /* Only increases to max rate will succeed, but that's actually good
214 * for debugging purposes. So we don't check for error. */
215 if (clock
->flags
& CLK_MAX
)
216 clk_set_max_rate(clock
, val
);
217 if (clock
->flags
& CLK_MIN
)
218 ret
= clk_set_min_rate(clock
, val
);
220 ret
= clk_set_rate(clock
, val
);
222 printk(KERN_ERR
"clk_set%s_rate failed (%d)\n",
223 (clock
->flags
& CLK_MIN
) ? "_min" : "", ret
);
227 static int clock_debug_rate_get(void *data
, u64
*val
)
229 struct clk
*clock
= data
;
230 *val
= clk_get_rate(clock
);
234 static int clock_debug_enable_set(void *data
, u64 val
)
236 struct clk
*clock
= data
;
240 rc
= clock
->ops
->enable(clock
->id
);
242 clock
->ops
->disable(clock
->id
);
247 static int clock_debug_enable_get(void *data
, u64
*val
)
249 struct clk
*clock
= data
;
251 *val
= clock
->ops
->is_enabled(clock
->id
);
256 static int clock_debug_local_get(void *data
, u64
*val
)
258 struct clk
*clock
= data
;
260 *val
= clock
->ops
!= &clk_ops_pcom
;
265 DEFINE_SIMPLE_ATTRIBUTE(clock_rate_fops
, clock_debug_rate_get
,
266 clock_debug_rate_set
, "%llu\n");
267 DEFINE_SIMPLE_ATTRIBUTE(clock_enable_fops
, clock_debug_enable_get
,
268 clock_debug_enable_set
, "%llu\n");
269 DEFINE_SIMPLE_ATTRIBUTE(clock_local_fops
, clock_debug_local_get
,
272 static int __init
clock_debug_init(void)
274 struct dentry
*dent_rate
, *dent_enable
, *dent_local
;
279 dent_rate
= debugfs_create_dir("clk_rate", 0);
280 if (IS_ERR(dent_rate
))
281 return PTR_ERR(dent_rate
);
283 dent_enable
= debugfs_create_dir("clk_enable", 0);
284 if (IS_ERR(dent_enable
))
285 return PTR_ERR(dent_enable
);
287 dent_local
= debugfs_create_dir("clk_local", NULL
);
288 if (IS_ERR(dent_local
))
289 return PTR_ERR(dent_local
);
291 while ((clock
= msm_clock_get_nth(n
++)) != 0) {
292 strncpy(temp
, clock
->dbg_name
, ARRAY_SIZE(temp
)-1);
293 for (ptr
= temp
; *ptr
; ptr
++)
294 *ptr
= tolower(*ptr
);
295 debugfs_create_file(temp
, 0644, dent_rate
,
296 clock
, &clock_rate_fops
);
297 debugfs_create_file(temp
, 0644, dent_enable
,
298 clock
, &clock_enable_fops
);
299 debugfs_create_file(temp
, S_IRUGO
, dent_local
,
300 clock
, &clock_local_fops
);
305 device_initcall(clock_debug_init
);
308 /* The bootloader and/or AMSS may have left various clocks enabled.
309 * Disable any clocks that belong to us (CLKFLAG_AUTO_OFF) but have
310 * not been explicitly enabled by a clk_enable() call.
312 static int __init
clock_late_init(void)
318 mutex_lock(&clocks_mutex
);
319 list_for_each_entry(clk
, &clocks
, list
) {
320 if (clk
->flags
& CLKFLAG_AUTO_OFF
) {
321 spin_lock_irqsave(&clocks_lock
, flags
);
324 clk
->ops
->auto_off(clk
->id
);
326 spin_unlock_irqrestore(&clocks_lock
, flags
);
329 mutex_unlock(&clocks_mutex
);
330 pr_info("clock_late_init() disabled %d unused clocks\n", count
);
334 late_initcall(clock_late_init
);