ARM: tegra: power: Set Tegra3 CPU/core rail nominal voltage
[linux-3.10.git] / arch / arm / mach-tegra / clock.h
1 /*
2  * arch/arm/mach-tegra/include/mach/clock.h
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Copyright (c) 2012 NVIDIA CORPORATION.  All rights reserved.
6  *
7  * Author:
8  *      Colin Cross <ccross@google.com>
9  *
10  * Copyright (C) 2010-2011, NVIDIA Corporation.
11  *
12  * This software is licensed under the terms of the GNU General Public
13  * License version 2, as published by the Free Software Foundation, and
14  * may be copied, distributed, and modified under those terms.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  */
22
23 #ifndef __MACH_TEGRA_CLOCK_H
24 #define __MACH_TEGRA_CLOCK_H
25
26 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
27 #define USE_PLL_LOCK_BITS 0     /* Never use lock bits on Tegra2 */
28 #else
29 /* !!!FIXME!!! PLL lock bits should work on Tegra3 */
30 #define USE_PLL_LOCK_BITS 0     /* Use lock bits for PLL stabiliation */
31 #define USE_PLLE_SS 1           /* Use spread spectrum coefficients for PLLE */
32 #endif
33
34 #include <linux/clk/tegra.h>
35
36 #define DIV_BUS                 (1 << 0)
37 #define DIV_U71                 (1 << 1)
38 #define DIV_U71_FIXED           (1 << 2)
39 #define DIV_2                   (1 << 3)
40 #define DIV_U16                 (1 << 4)
41 #define PLL_FIXED               (1 << 5)
42 #define PLL_HAS_CPCON           (1 << 6)
43 #define MUX                     (1 << 7)
44 #define PLLD                    (1 << 8)
45 #define PERIPH_NO_RESET         (1 << 9)
46 #define PERIPH_NO_ENB           (1 << 10)
47 #define PERIPH_EMC_ENB          (1 << 11)
48 #define PERIPH_MANUAL_RESET     (1 << 12)
49 #define PLL_ALT_MISC_REG        (1 << 13)
50 #define PLLU                    (1 << 14)
51 #define PLLX                    (1 << 15)
52 #define MUX_PWM                 (1 << 16)
53 #define MUX8                    (1 << 17)
54 #define DIV_U71_UART            (1 << 18)
55 #define MUX_CLK_OUT             (1 << 19)
56 #define PLLM                    (1 << 20)
57 #define DIV_U71_INT             (1 << 21)
58 #define DIV_U71_IDLE            (1 << 22)
59 #define ENABLE_ON_INIT          (1 << 28)
60 #define PERIPH_ON_APB           (1 << 29)
61
62 #ifndef __ASSEMBLY__
63
64 #include <linux/clk-provider.h>
65 #include <linux/clkdev.h>
66 #include <linux/list.h>
67 #include <linux/mutex.h>
68 #include <linux/spinlock.h>
69 #include <asm/cputime.h>
70
71 #define MAX_SAME_LIMIT_SKU_IDS  16
72
73 struct clk;
74
75 #ifdef CONFIG_COMMON_CLK
76 struct clk_tegra;
77 #define to_clk_tegra(_hw) container_of(_hw, struct clk_tegra, hw)
78 #endif
79
80 struct clk_mux_sel {
81         struct clk      *input;
82         u32             value;
83 };
84
85 struct clk_pll_freq_table {
86         unsigned long   input_rate;
87         unsigned long   output_rate;
88         u16             n;
89         u16             m;
90         u8              p;
91         u8              cpcon;
92 };
93
94 enum clk_state {
95         UNINITIALIZED = 0,
96         ON,
97         OFF,
98 };
99
100 #ifndef CONFIG_COMMON_CLK
101 struct clk_ops {
102         void            (*init)(struct clk *);
103         int             (*enable)(struct clk *);
104         void            (*disable)(struct clk *);
105         int             (*set_parent)(struct clk *, struct clk *);
106         int             (*set_rate)(struct clk *, unsigned long);
107         long            (*round_rate)(struct clk *, unsigned long);
108         void            (*reset)(struct clk *, bool);
109         int             (*clk_cfg_ex)(struct clk *,
110                                 enum tegra_clk_ex_param, u32);
111 };
112
113 struct clk_stats {
114         cputime64_t     time_on;
115         u64             last_update;
116 };
117
118 enum cpu_mode {
119         MODE_G = 0,
120         MODE_LP,
121 };
122
123 struct clk {
124         /* node for master clocks list */
125         struct list_head        node;           /* node for list of all clocks */
126         struct dvfs             *dvfs;
127         struct clk_lookup       lookup;
128
129 #ifdef CONFIG_DEBUG_FS
130         struct dentry           *dent;
131 #endif
132         bool                    set;
133         struct clk_ops          *ops;
134         unsigned long           dvfs_rate;
135         unsigned long           rate;
136         unsigned long           max_rate;
137         unsigned long           min_rate;
138         bool                    auto_dvfs;
139         bool                    cansleep;
140         u32                     flags;
141         const char              *name;
142
143         u32                     refcnt;
144         enum clk_state          state;
145         struct clk              *parent;
146         u32                     div;
147         u32                     mul;
148         struct clk_stats        stats;
149
150         const struct clk_mux_sel        *inputs;
151         u32                             reg;
152         u32                             reg_shift;
153
154         struct list_head                shared_bus_list;
155
156         union {
157                 struct {
158                         unsigned int                    clk_num;
159                 } periph;
160                 struct {
161                         unsigned long                   input_min;
162                         unsigned long                   input_max;
163                         unsigned long                   cf_min;
164                         unsigned long                   cf_max;
165                         unsigned long                   vco_min;
166                         unsigned long                   vco_max;
167                         const struct clk_pll_freq_table *freq_table;
168                         int                             lock_delay;
169                         unsigned long                   fixed_rate;
170                 } pll;
171                 struct {
172                         u32                             sel;
173                         u32                             reg_mask;
174                 } mux;
175                 struct {
176                         struct clk                      *main;
177                         struct clk                      *backup;
178                         enum cpu_mode                   mode;
179                 } cpu;
180                 struct {
181                         struct clk                      *pclk;
182                         struct clk                      *hclk;
183                         struct clk                      *sclk_low;
184                         struct clk                      *sclk_high;
185                         unsigned long                   threshold;
186                 } system;
187                 struct {
188                         struct list_head                node;
189                         bool                            enabled;
190                         unsigned long                   rate;
191                 } shared_bus_user;
192         } u;
193
194         struct mutex mutex;
195         spinlock_t spinlock;
196 };
197
198 #else
199
200 struct clk_tegra {
201         /* node for master clocks list */
202         struct list_head        node;   /* node for list of all clocks */
203         struct clk_lookup       lookup;
204         struct clk_hw           hw;
205
206         bool                    set;
207         unsigned long           fixed_rate;
208         unsigned long           max_rate;
209         unsigned long           min_rate;
210         u32                     flags;
211         const char              *name;
212
213         enum clk_state          state;
214         u32                     div;
215         u32                     mul;
216
217         u32                             reg;
218         u32                             reg_shift;
219
220         struct list_head                shared_bus_list;
221
222         union {
223                 struct {
224                         unsigned int                    clk_num;
225                 } periph;
226                 struct {
227                         unsigned long                   input_min;
228                         unsigned long                   input_max;
229                         unsigned long                   cf_min;
230                         unsigned long                   cf_max;
231                         unsigned long                   vco_min;
232                         unsigned long                   vco_max;
233                         const struct clk_pll_freq_table *freq_table;
234                         int                             lock_delay;
235                         unsigned long                   fixed_rate;
236                 } pll;
237                 struct {
238                         u32                             sel;
239                         u32                             reg_mask;
240                 } mux;
241                 struct {
242                         struct clk                      *main;
243                         struct clk                      *backup;
244                 } cpu;
245                 struct {
246                         struct list_head                node;
247                         bool                            enabled;
248                         unsigned long                   rate;
249                 } shared_bus_user;
250         } u;
251
252         void (*reset)(struct clk_hw *, bool);
253         int (*clk_cfg_ex)(struct clk_hw *, enum tegra_clk_ex_param, u32);
254 };
255 #endif /* !CONFIG_COMMON_CLK */
256
257 struct clk_duplicate {
258         const char *name;
259         struct clk_lookup lookup;
260 };
261
262 struct tegra_clk_init_table {
263         const char *name;
264         const char *parent;
265         unsigned long rate;
266         bool enabled;
267 };
268
269 #ifndef CONFIG_COMMON_CLK
270 void tegra_init_max_rate(struct clk *c, unsigned long max_rate);
271 void clk_init(struct clk *clk);
272 unsigned long clk_get_rate_locked(struct clk *c);
273 void clk_set_cansleep(struct clk *c);
274 unsigned long clk_get_min_rate(struct clk *c);
275 unsigned long clk_get_max_rate(struct clk *c);
276 int clk_set_rate_locked(struct clk *c, unsigned long rate);
277 int clk_reparent(struct clk *c, struct clk *parent);
278 int tegra_emc_set_rate(unsigned long rate);
279 long tegra_emc_round_rate(unsigned long rate);
280 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value);
281 void tegra_emc_timing_invalidate(void);
282 #endif /* !CONFIG_COMMON_CLK */
283
284 struct tegra_sku_rate_limit {
285         const char *clk_name;
286         unsigned long max_rate;
287         int sku_ids[MAX_SAME_LIMIT_SKU_IDS];
288 };
289
290 void tegra2_init_clocks(void);
291 void tegra30_init_clocks(void);
292 struct clk *tegra_get_clock_by_name(const char *name);
293 void tegra_clk_init_from_table(struct tegra_clk_init_table *table);
294
295 #ifndef CONFIG_COMMON_CLK
296 static inline bool clk_is_auto_dvfs(struct clk *c)
297 {
298         return c->auto_dvfs;
299 }
300
301 static inline bool clk_is_dvfs(struct clk *c)
302 {
303         return (c->dvfs != NULL);
304 }
305
306 static inline bool clk_cansleep(struct clk *c)
307 {
308         return c->cansleep;
309 }
310
311 static inline void clk_lock_save(struct clk *c, unsigned long *flags)
312 {
313         if (clk_cansleep(c)) {
314                 *flags = 0;
315                 mutex_lock(&c->mutex);
316         } else {
317                 spin_lock_irqsave(&c->spinlock, *flags);
318         }
319 }
320
321 static inline void clk_unlock_restore(struct clk *c, unsigned long *flags)
322 {
323         if (clk_cansleep(c))
324                 mutex_unlock(&c->mutex);
325         else
326                 spin_unlock_irqrestore(&c->spinlock, *flags);
327 }
328
329 static inline void clk_lock_init(struct clk *c)
330 {
331         mutex_init(&c->mutex);
332         spin_lock_init(&c->spinlock);
333 }
334 #endif
335
336 #ifdef CONFIG_CPU_FREQ
337 struct cpufreq_frequency_table;
338
339 struct tegra_cpufreq_table_data {
340         struct cpufreq_frequency_table *freq_table;
341         int throttle_lowest_index;
342         int throttle_highest_index;
343 };
344 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void);
345 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate);
346 #endif
347
348 #endif
349 #endif