unknown changes from android-tegra-nv-3.4
[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-2012, 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 #ifndef __ASSEMBLY__
27
28 #include <linux/clk-provider.h>
29 #include <linux/clkdev.h>
30 #include <linux/list.h>
31 #include <linux/mutex.h>
32 #include <linux/spinlock.h>
33 #include <linux/clk/tegra.h>
34 #include <asm/cputime.h>
35
36 #define MAX_SAME_LIMIT_SKU_IDS  16
37
38 struct clk;
39
40 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
41 #define USE_PLL_LOCK_BITS 0     /* Never use lock bits on Tegra2 */
42 #else
43 #define USE_PLL_LOCK_BITS 1     /* Use lock bits for PLL stabiliation */
44 #define USE_PLLE_SS 1           /* Use spread spectrum coefficients for PLLE */
45 #define PLL_POST_LOCK_DELAY 50  /* Safety delay after lock is detected */
46 #endif
47
48 #define DIV_BUS                 (1 << 0)
49 #define DIV_U71                 (1 << 1)
50 #define DIV_U71_FIXED           (1 << 2)
51 #define DIV_2                   (1 << 3)
52 #define DIV_U16                 (1 << 4)
53 #define PLL_FIXED               (1 << 5)
54 #define PLL_HAS_CPCON           (1 << 6)
55 #define MUX                     (1 << 7)
56 #define PLLD                    (1 << 8)
57 #define PERIPH_NO_RESET         (1 << 9)
58 #define PERIPH_NO_ENB           (1 << 10)
59 #define PERIPH_EMC_ENB          (1 << 11)
60 #define PERIPH_MANUAL_RESET     (1 << 12)
61 #define PLL_ALT_MISC_REG        (1 << 13)
62 #define PLLU                    (1 << 14)
63 #define PLLX                    (1 << 15)
64 #define MUX_PWM                 (1 << 16)
65 #define MUX8                    (1 << 17)
66 #define DIV_U151_UART           (1 << 18)
67 #define MUX_CLK_OUT             (1 << 19)
68 #define PLLM                    (1 << 20)
69 #define DIV_U71_INT             (1 << 21)
70 #define DIV_U71_IDLE            (1 << 22)
71 #define DIV_U151                (1 << 23)
72 #define ENABLE_ON_INIT          (1 << 28)
73 #define PERIPH_ON_APB           (1 << 29)
74 #define PERIPH_ON_CBUS          (1 << 30)
75
76 #ifdef CONFIG_COMMON_CLK
77 struct clk_tegra;
78 #define to_clk_tegra(_hw) container_of(_hw, struct clk_tegra, hw)
79 #endif
80
81 struct clk_mux_sel {
82         struct clk      *input;
83         u32             value;
84 };
85
86 struct clk_pll_freq_table {
87         unsigned long   input_rate;
88         unsigned long   output_rate;
89         u16             n;
90         u16             m;
91         u8              p;
92         u8              cpcon;
93 };
94
95 enum clk_state {
96         UNINITIALIZED = 0,
97         ON,
98         OFF,
99 };
100
101 #ifndef CONFIG_COMMON_CLK
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 struct clk {
133         /* node for master clocks list */
134         struct list_head        node;           /* node for list of all clocks */
135         struct dvfs             *dvfs;
136         struct clk_lookup       lookup;
137
138 #ifdef CONFIG_DEBUG_FS
139         struct dentry           *dent;
140 #endif
141         bool                    set;
142         struct clk_ops          *ops;
143         unsigned long           dvfs_rate;
144         unsigned long           rate;
145         unsigned long           max_rate;
146         unsigned long           min_rate;
147         bool                    auto_dvfs;
148         bool                    cansleep;
149         u32                     flags;
150         const char              *name;
151
152         u32                     refcnt;
153         enum clk_state          state;
154         struct clk              *parent;
155         u32                     div;
156         u32                     mul;
157         struct clk_stats        stats;
158
159         const struct clk_mux_sel        *inputs;
160         u32                             reg;
161         u32                             reg_shift;
162
163         struct list_head                shared_bus_list;
164         struct clk_mux_sel              shared_bus_backup;
165
166         union {
167                 struct {
168                         unsigned int                    clk_num;
169                 } periph;
170                 struct {
171                         unsigned long                   input_min;
172                         unsigned long                   input_max;
173                         unsigned long                   cf_min;
174                         unsigned long                   cf_max;
175                         unsigned long                   vco_min;
176                         unsigned long                   vco_max;
177                         const struct clk_pll_freq_table *freq_table;
178                         int                             lock_delay;
179                         unsigned long                   fixed_rate;
180                 } pll;
181                 struct {
182                         unsigned long                   default_rate;
183                 } pll_div;
184                 struct {
185                         u32                             sel;
186                         u32                             reg_mask;
187                 } mux;
188                 struct {
189                         struct clk                      *main;
190                         struct clk                      *backup;
191                         unsigned long                   backup_rate;
192                         enum cpu_mode                   mode;
193                 } cpu;
194                 struct {
195                         u32                             div71;
196                 } cclk;
197                 struct {
198                         struct clk                      *pclk;
199                         struct clk                      *hclk;
200                         struct clk                      *sclk_low;
201                         struct clk                      *sclk_high;
202                         unsigned long                   threshold;
203                 } system;
204                 struct {
205                         struct list_head                node;
206                         bool                            enabled;
207                         unsigned long                   rate;
208                         const char                      *client_id;
209                         struct clk                      *client;
210                         u32                             client_div;
211                         enum shared_bus_users_mode      mode;
212                 } shared_bus_user;
213         } u;
214
215         struct raw_notifier_head                        *rate_change_nh;
216
217         struct mutex mutex;
218         spinlock_t spinlock;
219 };
220
221 #else
222
223 struct clk_tegra {
224         /* node for master clocks list */
225         struct list_head        node;   /* node for list of all clocks */
226         struct clk_lookup       lookup;
227         struct clk_hw           hw;
228
229         bool                    set;
230         unsigned long           fixed_rate;
231         unsigned long           max_rate;
232         unsigned long           min_rate;
233         u32                     flags;
234         const char              *name;
235
236         enum clk_state          state;
237         u32                     div;
238         u32                     mul;
239
240         u32                             reg;
241         u32                             reg_shift;
242
243         struct list_head                shared_bus_list;
244
245         union {
246                 struct {
247                         unsigned int                    clk_num;
248                 } periph;
249                 struct {
250                         unsigned long                   input_min;
251                         unsigned long                   input_max;
252                         unsigned long                   cf_min;
253                         unsigned long                   cf_max;
254                         unsigned long                   vco_min;
255                         unsigned long                   vco_max;
256                         const struct clk_pll_freq_table *freq_table;
257                         int                             lock_delay;
258                         unsigned long                   fixed_rate;
259                 } pll;
260                 struct {
261                         u32                             sel;
262                         u32                             reg_mask;
263                 } mux;
264                 struct {
265                         struct clk                      *main;
266                         struct clk                      *backup;
267                 } cpu;
268                 struct {
269                         struct list_head                node;
270                         bool                            enabled;
271                         unsigned long                   rate;
272                 } shared_bus_user;
273         } u;
274
275         void (*reset)(struct clk_hw *, bool);
276         int (*clk_cfg_ex)(struct clk_hw *, enum tegra_clk_ex_param, u32);
277 };
278 #endif /* !CONFIG_COMMON_CLK */
279
280 struct clk_duplicate {
281         const char *name;
282         struct clk_lookup lookup;
283 };
284
285 struct tegra_clk_init_table {
286         const char *name;
287         const char *parent;
288         unsigned long rate;
289         bool enabled;
290 };
291
292 #ifndef CONFIG_COMMON_CLK
293 void tegra_init_max_rate(struct clk *c, unsigned long max_rate);
294 void clk_init(struct clk *clk);
295 unsigned long clk_get_rate_locked(struct clk *c);
296 void clk_set_cansleep(struct clk *c);
297 unsigned long clk_get_min_rate(struct clk *c);
298 unsigned long clk_get_max_rate(struct clk *c);
299 int clk_set_rate_locked(struct clk *c, unsigned long rate);
300 int clk_set_parent_locked(struct clk *c, struct clk *parent);
301 int clk_reparent(struct clk *c, struct clk *parent);
302 long clk_round_rate_locked(struct clk *c, unsigned long rate);
303 int tegra_clk_shared_bus_update(struct clk *c);
304 void tegra3_set_cpu_skipper_delay(int delay);
305 int tegra_emc_set_rate(unsigned long rate);
306 long tegra_emc_round_rate(unsigned long rate);
307 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value);
308 void tegra_emc_timing_invalidate(void);
309 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
310 static inline bool tegra_clk_is_parent_allowed(struct clk *c, struct clk *p)
311 { return true; }
312 #else
313 bool tegra_clk_is_parent_allowed(struct clk *c, struct clk *p);
314 #endif
315 #endif /* !CONFIG_COMMON_CLK */
316
317 struct tegra_sku_rate_limit {
318         const char *clk_name;
319         unsigned long max_rate;
320         int sku_ids[MAX_SAME_LIMIT_SKU_IDS];
321 };
322
323 void tegra2_init_clocks(void);
324 void tegra30_init_clocks(void);
325 void tegra_common_init_clock(void);
326 struct clk *tegra_get_clock_by_name(const char *name);
327 void tegra_clk_init_from_table(struct tegra_clk_init_table *table);
328
329 #ifndef CONFIG_COMMON_CLK
330 static inline bool clk_is_auto_dvfs(struct clk *c)
331 {
332         return c->auto_dvfs;
333 }
334
335 static inline bool clk_is_dvfs(struct clk *c)
336 {
337         return (c->dvfs != NULL);
338 }
339
340 static inline bool clk_cansleep(struct clk *c)
341 {
342         return c->cansleep;
343 }
344
345 static inline void clk_lock_save(struct clk *c, unsigned long *flags)
346 {
347         if (clk_cansleep(c)) {
348                 *flags = 0;
349                 mutex_lock(&c->mutex);
350         } else {
351                 spin_lock_irqsave(&c->spinlock, *flags);
352         }
353 }
354
355 static inline void clk_unlock_restore(struct clk *c, unsigned long *flags)
356 {
357         if (clk_cansleep(c))
358                 mutex_unlock(&c->mutex);
359         else
360                 spin_unlock_irqrestore(&c->spinlock, *flags);
361 }
362
363 static inline void clk_lock_init(struct clk *c)
364 {
365         mutex_init(&c->mutex);
366         spin_lock_init(&c->spinlock);
367 }
368 #endif
369
370 #ifdef CONFIG_CPU_FREQ
371 struct cpufreq_frequency_table;
372
373 struct tegra_cpufreq_table_data {
374         struct cpufreq_frequency_table *freq_table;
375         int throttle_lowest_index;
376         int throttle_highest_index;
377         int suspend_index;
378 };
379 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void);
380 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate);
381 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
382 static inline int tegra_update_mselect_rate(unsigned long cpu_rate)
383 { return 0; }
384 #else
385 int tegra_update_mselect_rate(unsigned long cpu_rate);
386 #endif
387 #endif
388
389 #endif
390 #endif