]>
Commit | Line | Data |
---|---|---|
600f7cfe BS |
1 | /* arch/arm/mach-msm/clock.c |
2 | * | |
3 | * Copyright (C) 2007 Google, Inc. | |
5e96da5d | 4 | * Copyright (c) 2007-2010, Code Aurora Forum. All rights reserved. |
600f7cfe BS |
5 | * |
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. | |
9 | * | |
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. | |
14 | * | |
15 | */ | |
16 | ||
600f7cfe | 17 | #include <linux/kernel.h> |
600f7cfe BS |
18 | #include <linux/list.h> |
19 | #include <linux/err.h> | |
600f7cfe | 20 | #include <linux/spinlock.h> |
e8db0be1 | 21 | #include <linux/pm_qos.h> |
bd32344a SB |
22 | #include <linux/mutex.h> |
23 | #include <linux/clk.h> | |
24 | #include <linux/string.h> | |
25 | #include <linux/module.h> | |
26 | #include <linux/clkdev.h> | |
600f7cfe BS |
27 | |
28 | #include "clock.h" | |
600f7cfe BS |
29 | |
30 | static DEFINE_MUTEX(clocks_mutex); | |
31 | static DEFINE_SPINLOCK(clocks_lock); | |
32 | static LIST_HEAD(clocks); | |
33 | ||
600f7cfe BS |
34 | /* |
35 | * Standard clock functions defined in include/linux/clk.h | |
36 | */ | |
600f7cfe BS |
37 | int clk_enable(struct clk *clk) |
38 | { | |
39 | unsigned long flags; | |
40 | spin_lock_irqsave(&clocks_lock, flags); | |
41 | clk->count++; | |
437f629d | 42 | if (clk->count == 1) |
5e96da5d | 43 | clk->ops->enable(clk->id); |
600f7cfe BS |
44 | spin_unlock_irqrestore(&clocks_lock, flags); |
45 | return 0; | |
46 | } | |
47 | EXPORT_SYMBOL(clk_enable); | |
48 | ||
49 | void clk_disable(struct clk *clk) | |
50 | { | |
51 | unsigned long flags; | |
52 | spin_lock_irqsave(&clocks_lock, flags); | |
53 | BUG_ON(clk->count == 0); | |
54 | clk->count--; | |
437f629d | 55 | if (clk->count == 0) |
5e96da5d | 56 | clk->ops->disable(clk->id); |
600f7cfe BS |
57 | spin_unlock_irqrestore(&clocks_lock, flags); |
58 | } | |
59 | EXPORT_SYMBOL(clk_disable); | |
60 | ||
5e96da5d DW |
61 | int clk_reset(struct clk *clk, enum clk_reset_action action) |
62 | { | |
5e96da5d DW |
63 | return clk->ops->reset(clk->remote_id, action); |
64 | } | |
65 | EXPORT_SYMBOL(clk_reset); | |
66 | ||
600f7cfe BS |
67 | unsigned long clk_get_rate(struct clk *clk) |
68 | { | |
5e96da5d | 69 | return clk->ops->get_rate(clk->id); |
600f7cfe BS |
70 | } |
71 | EXPORT_SYMBOL(clk_get_rate); | |
72 | ||
73 | int clk_set_rate(struct clk *clk, unsigned long rate) | |
74 | { | |
3a790bbe DW |
75 | int ret; |
76 | if (clk->flags & CLKFLAG_MAX) { | |
77 | ret = clk->ops->set_max_rate(clk->id, rate); | |
78 | if (ret) | |
79 | return ret; | |
80 | } | |
81 | if (clk->flags & CLKFLAG_MIN) { | |
82 | ret = clk->ops->set_min_rate(clk->id, rate); | |
83 | if (ret) | |
84 | return ret; | |
85 | } | |
86 | ||
87 | if (clk->flags & CLKFLAG_MAX || clk->flags & CLKFLAG_MIN) | |
88 | return ret; | |
89 | ||
5e96da5d | 90 | return clk->ops->set_rate(clk->id, rate); |
600f7cfe BS |
91 | } |
92 | EXPORT_SYMBOL(clk_set_rate); | |
93 | ||
5e96da5d DW |
94 | long clk_round_rate(struct clk *clk, unsigned long rate) |
95 | { | |
96 | return clk->ops->round_rate(clk->id, rate); | |
97 | } | |
98 | EXPORT_SYMBOL(clk_round_rate); | |
99 | ||
600f7cfe BS |
100 | int clk_set_parent(struct clk *clk, struct clk *parent) |
101 | { | |
102 | return -ENOSYS; | |
103 | } | |
104 | EXPORT_SYMBOL(clk_set_parent); | |
105 | ||
106 | struct clk *clk_get_parent(struct clk *clk) | |
107 | { | |
108 | return ERR_PTR(-ENOSYS); | |
109 | } | |
110 | EXPORT_SYMBOL(clk_get_parent); | |
111 | ||
5e96da5d DW |
112 | /* EBI1 is the only shared clock that several clients want to vote on as of |
113 | * this commit. If this changes in the future, then it might be better to | |
114 | * make clk_min_rate handle the voting or make ebi1_clk_set_min_rate more | |
115 | * generic to support different clocks. | |
116 | */ | |
117 | static struct clk *ebi1_clk; | |
600f7cfe | 118 | |
421faca0 | 119 | void msm_clock_init(struct clk_lookup *clock_tbl, size_t num_clocks) |
600f7cfe BS |
120 | { |
121 | unsigned n; | |
122 | ||
600f7cfe | 123 | mutex_lock(&clocks_mutex); |
bd32344a SB |
124 | for (n = 0; n < num_clocks; n++) { |
125 | clkdev_add(&clock_tbl[n]); | |
126 | list_add_tail(&clock_tbl[n].clk->list, &clocks); | |
127 | } | |
600f7cfe | 128 | mutex_unlock(&clocks_mutex); |
5e96da5d DW |
129 | |
130 | ebi1_clk = clk_get(NULL, "ebi1_clk"); | |
131 | BUG_ON(ebi1_clk == NULL); | |
132 | ||
133 | } | |
134 | ||
600f7cfe BS |
135 | /* The bootloader and/or AMSS may have left various clocks enabled. |
136 | * Disable any clocks that belong to us (CLKFLAG_AUTO_OFF) but have | |
137 | * not been explicitly enabled by a clk_enable() call. | |
138 | */ | |
139 | static int __init clock_late_init(void) | |
140 | { | |
141 | unsigned long flags; | |
142 | struct clk *clk; | |
143 | unsigned count = 0; | |
144 | ||
d64560fe | 145 | clock_debug_init(); |
600f7cfe BS |
146 | mutex_lock(&clocks_mutex); |
147 | list_for_each_entry(clk, &clocks, list) { | |
d64560fe | 148 | clock_debug_add(clk); |
600f7cfe BS |
149 | if (clk->flags & CLKFLAG_AUTO_OFF) { |
150 | spin_lock_irqsave(&clocks_lock, flags); | |
151 | if (!clk->count) { | |
152 | count++; | |
5e96da5d | 153 | clk->ops->auto_off(clk->id); |
600f7cfe BS |
154 | } |
155 | spin_unlock_irqrestore(&clocks_lock, flags); | |
156 | } | |
157 | } | |
158 | mutex_unlock(&clocks_mutex); | |
159 | pr_info("clock_late_init() disabled %d unused clocks\n", count); | |
160 | return 0; | |
161 | } | |
162 | ||
163 | late_initcall(clock_late_init); | |
5e96da5d | 164 |