ARM: tegra: dvfs: Add interface to set fmax at vmin
[linux-3.10.git] / include / linux / clk / tegra.h
1 /*
2  * Copyright (c) 2012-2014, NVIDIA CORPORATION.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15  */
16
17 #ifndef __LINUX_CLK_TEGRA_H_
18 #define __LINUX_CLK_TEGRA_H_
19
20 #include <linux/clk.h>
21
22 /*
23  * Tegra CPU clock and reset control ops
24  *
25  * wait_for_reset:
26  *      keep waiting until the CPU in reset state
27  * put_in_reset:
28  *      put the CPU in reset state
29  * out_of_reset:
30  *      release the CPU from reset state
31  * enable_clock:
32  *      CPU clock un-gate
33  * disable_clock:
34  *      CPU clock gate
35  * rail_off_ready:
36  *      CPU is ready for rail off
37  * suspend:
38  *      save the clock settings when CPU go into low-power state
39  * resume:
40  *      restore the clock settings when CPU exit low-power state
41  */
42 struct tegra_cpu_car_ops {
43         void (*wait_for_reset)(u32 cpu);
44         void (*put_in_reset)(u32 cpu);
45         void (*out_of_reset)(u32 cpu);
46         void (*enable_clock)(u32 cpu);
47         void (*disable_clock)(u32 cpu);
48 #ifdef CONFIG_PM_SLEEP
49         bool (*rail_off_ready)(void);
50         void (*suspend)(void);
51         void (*resume)(void);
52 #endif
53 };
54
55 extern struct tegra_cpu_car_ops *tegra_cpu_car_ops;
56
57 static inline void tegra_wait_cpu_in_reset(u32 cpu)
58 {
59         if (WARN_ON(!tegra_cpu_car_ops->wait_for_reset))
60                 return;
61
62         tegra_cpu_car_ops->wait_for_reset(cpu);
63 }
64
65 static inline void tegra_put_cpu_in_reset(u32 cpu)
66 {
67         if (WARN_ON(!tegra_cpu_car_ops->put_in_reset))
68                 return;
69
70         tegra_cpu_car_ops->put_in_reset(cpu);
71 }
72
73 static inline void tegra_cpu_out_of_reset(u32 cpu)
74 {
75         if (WARN_ON(!tegra_cpu_car_ops->out_of_reset))
76                 return;
77
78         tegra_cpu_car_ops->out_of_reset(cpu);
79 }
80
81 static inline void tegra_enable_cpu_clock(u32 cpu)
82 {
83         if (WARN_ON(!tegra_cpu_car_ops->enable_clock))
84                 return;
85
86         tegra_cpu_car_ops->enable_clock(cpu);
87 }
88
89 static inline void tegra_disable_cpu_clock(u32 cpu)
90 {
91         if (WARN_ON(!tegra_cpu_car_ops->disable_clock))
92                 return;
93
94         tegra_cpu_car_ops->disable_clock(cpu);
95 }
96
97 #ifdef CONFIG_PM_SLEEP
98 static inline bool tegra_cpu_rail_off_ready(void)
99 {
100         if (WARN_ON(!tegra_cpu_car_ops->rail_off_ready))
101                 return false;
102
103         return tegra_cpu_car_ops->rail_off_ready();
104 }
105
106 static inline void tegra_cpu_clock_suspend(void)
107 {
108         if (WARN_ON(!tegra_cpu_car_ops->suspend))
109                 return;
110
111         tegra_cpu_car_ops->suspend();
112 }
113
114 static inline void tegra_cpu_clock_resume(void)
115 {
116         if (WARN_ON(!tegra_cpu_car_ops->resume))
117                 return;
118
119         tegra_cpu_car_ops->resume();
120 }
121 #endif
122
123 enum tegra_clk_ex_param {
124         TEGRA_CLK_VI_INP_SEL,
125         TEGRA_CLK_DTV_INVERT,
126         TEGRA_CLK_NAND_PAD_DIV2_ENB,
127         TEGRA_CLK_PLLD_CSI_OUT_ENB,
128         TEGRA_CLK_PLLD_DSI_OUT_ENB,
129         TEGRA_CLK_PLLD_MIPI_MUX_SEL,
130         TEGRA_CLK_DFLL_LOCK,
131         TEGRA_CLK_SOR_CLK_SEL,
132         TEGRA_CLK_MIPI_CSI_OUT_ENB,
133 };
134
135 void tegra_periph_reset_deassert(struct clk *c);
136 void tegra_periph_reset_assert(struct clk *c);
137
138 #ifdef CONFIG_COMMON_CLK
139 void tegra_clocks_init(void);
140 void tegra_clocks_apply_init_table(void);
141
142 static inline int tegra_dvfs_override_core_voltage(struct clk *c, int override_mv)
143 {
144         return -EINVAL;
145 }
146 static inline int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
147 {
148         return -EINVAL;
149 }
150 #else
151 static inline void tegra_clocks_init(void)
152 {}
153 static inline void tegra_clocks_apply_init_table(void)
154 {}
155
156 struct dvfs;
157 struct notifier_block;
158
159 int tegra_dvfs_get_freqs(struct clk *c, unsigned long **freqs, int *num_freqs);
160 int tegra_dvfs_set_rate(struct clk *c, unsigned long rate);
161 int tegra_dvfs_override_core_voltage(struct clk *c, int override_mv);
162 int tegra_dvfs_set_fmax_at_vmin(struct clk *c, unsigned long f_max, int v_min);
163 unsigned long clk_get_rate_all_locked(struct clk *c);
164 int tegra_dvfs_rail_disable_by_name(const char *reg_id);
165 int tegra_register_clk_rate_notifier(struct clk *c, struct notifier_block *nb);
166 void tegra_unregister_clk_rate_notifier(
167         struct clk *c, struct notifier_block *nb);
168 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting);
169 int tegra_dvfs_use_alt_freqs_on_clk(struct clk *c, bool use_alt_freq);
170
171 /**
172  * tegra_is_clk_enabled - get info if the clk is enabled or not
173  * @clk: clock source
174  *
175  * Returns refcnt.
176  */
177 int tegra_is_clk_enabled(struct clk *clk);
178
179 void tegra_cpu_user_cap_set(unsigned int speed_khz);
180
181 struct tegra_clk_export_ops {
182         void            (*init)(void *data, unsigned long *rate, bool *state);
183         int             (*enable)(void *data);
184         void            (*disable)(void *data);
185         int             (*set_rate)(void *data, unsigned long *rate);
186         void            *data;
187 };
188
189 int tegra_clk_register_export_ops(struct clk *c,
190                                   struct tegra_clk_export_ops *ops);
191
192 struct clk *tegra_get_clock_by_name(const char *name);
193
194 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_FUNC
195 int tegra_clk_set_max(struct clk *c, unsigned long rate);
196 #ifdef CONFIG_ARCH_TEGRA_12x_SOC
197 void tegra_gbus_round_pass_thru_enable(bool enable);
198 #else
199 static inline void tegra_gbus_round_pass_thru_enable(bool enable)
200 {}
201 #endif
202 #else
203 static inline int tegra_clk_set_max(struct clk *c, unsigned long rate) {
204         return -ENOSYS;
205 }
206 static inline void tegra_gbus_round_pass_thru_enable(bool enable)
207 {}
208 #endif
209
210 #endif
211
212 #endif /* __LINUX_CLK_TEGRA_H_ */