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