4fec266d8d57ea3fed108cb932f2fe5843856c8a
[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  * This software is licensed under the terms of the GNU General Public
10  * License version 2, as published by the Free Software Foundation, and
11  * may be copied, distributed, and modified under those terms.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  */
19
20 #ifndef __MACH_TEGRA_CLOCK_H
21 #define __MACH_TEGRA_CLOCK_H
22
23 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
24 #define USE_PLL_LOCK_BITS 0     /* Never use lock bits on Tegra2 */
25 #else
26 /* !!!FIXME!!! PLL lock bits should work on Tegra3 */
27 #define USE_PLL_LOCK_BITS 0     /* Use lock bits for PLL stabiliation */
28 #define USE_PLLE_SS 1           /* Use spread spectrum coefficients for PLLE */
29 #endif
30
31 #define DIV_BUS                 (1 << 0)
32 #define DIV_U71                 (1 << 1)
33 #define DIV_U71_FIXED           (1 << 2)
34 #define DIV_2                   (1 << 3)
35 #define DIV_U16                 (1 << 4)
36 #define PLL_FIXED               (1 << 5)
37 #define PLL_HAS_CPCON           (1 << 6)
38 #define MUX                     (1 << 7)
39 #define PLLD                    (1 << 8)
40 #define PERIPH_NO_RESET         (1 << 9)
41 #define PERIPH_NO_ENB           (1 << 10)
42 #define PERIPH_EMC_ENB          (1 << 11)
43 #define PERIPH_MANUAL_RESET     (1 << 12)
44 #define PLL_ALT_MISC_REG        (1 << 13)
45 #define PLLU                    (1 << 14)
46 #define PLLX                    (1 << 15)
47 #define MUX_PWM                 (1 << 16)
48 #define MUX8                    (1 << 17)
49 #define DIV_U71_UART            (1 << 18)
50 #define MUX_CLK_OUT             (1 << 19)
51 #define PLLM                    (1 << 20)
52 #define ENABLE_ON_INIT          (1 << 28)
53
54 #ifndef __ASSEMBLY__
55
56 #include <linux/clkdev.h>
57 #include <linux/list.h>
58 #include <linux/mutex.h>
59 #include <linux/spinlock.h>
60
61 #include <mach/clk.h>
62 #define MAX_SAME_LIMIT_SKU_IDS  16
63
64 struct clk;
65
66 struct clk_mux_sel {
67         struct clk      *input;
68         u32             value;
69 };
70
71 struct clk_pll_freq_table {
72         unsigned long   input_rate;
73         unsigned long   output_rate;
74         u16             n;
75         u16             m;
76         u8              p;
77         u8              cpcon;
78 };
79
80 struct clk_ops {
81         void            (*init)(struct clk *);
82         int             (*enable)(struct clk *);
83         void            (*disable)(struct clk *);
84         int             (*set_parent)(struct clk *, struct clk *);
85         int             (*set_rate)(struct clk *, unsigned long);
86         long            (*round_rate)(struct clk *, unsigned long);
87         unsigned long   (*get_max_rate)(struct clk *);
88         void            (*recalculate_rate)(struct clk *);
89         int             (*clk_cfg_ex)(struct clk *, enum tegra_clk_ex_param, u32);
90         void            (*reset)(struct clk *, bool);
91 };
92
93 enum clk_state {
94         UNINITIALIZED = 0,
95         ON,
96         OFF,
97 };
98
99 struct clk {
100         /* node for master clocks list */
101         struct list_head        node;           /* node for list of all clocks */
102         struct dvfs             *dvfs;
103         struct clk_lookup       lookup;
104
105 #ifdef CONFIG_DEBUG_FS
106         struct dentry           *dent;
107 #endif
108         bool                    set;
109         struct clk_ops          *ops;
110         unsigned long           dvfs_rate;
111         unsigned long           rate;
112         unsigned long           max_rate;
113         unsigned long           min_rate;
114         bool                    auto_dvfs;
115         bool                    cansleep;
116         u32                     flags;
117         const char              *name;
118
119         u32                     refcnt;
120         enum clk_state          state;
121         struct clk              *parent;
122         u32                     div;
123         u32                     mul;
124
125         const struct clk_mux_sel        *inputs;
126         u32                             reg;
127         u32                             reg_shift;
128
129         struct list_head                shared_bus_list;
130
131         union {
132                 struct {
133                         unsigned int                    clk_num;
134                 } periph;
135                 struct {
136                         unsigned long                   input_min;
137                         unsigned long                   input_max;
138                         unsigned long                   cf_min;
139                         unsigned long                   cf_max;
140                         unsigned long                   vco_min;
141                         unsigned long                   vco_max;
142                         const struct clk_pll_freq_table *freq_table;
143                         int                             lock_delay;
144                         unsigned long                   fixed_rate;
145                 } pll;
146                 struct {
147                         u32                             sel;
148                         u32                             reg_mask;
149                 } mux;
150                 struct {
151                         struct clk                      *main;
152                         struct clk                      *backup;
153                         unsigned long                   lp_max_rate;
154                 } cpu;
155                 struct {
156                         struct list_head                node;
157                         bool                            enabled;
158                         unsigned long                   rate;
159                 } shared_bus_user;
160         } u;
161
162         struct mutex mutex;
163         spinlock_t spinlock;
164 };
165
166 struct clk_duplicate {
167         const char *name;
168         struct clk_lookup lookup;
169 };
170
171 struct tegra_clk_init_table {
172         const char *name;
173         const char *parent;
174         unsigned long rate;
175         bool enabled;
176 };
177
178 struct tegra_sku_rate_limit {
179         const char *clk_name;
180         unsigned long max_rate;
181         int sku_ids[MAX_SAME_LIMIT_SKU_IDS];
182 };
183
184 void tegra_soc_init_clocks(void);
185 void tegra2_init_clocks(void);
186 void tegra2_periph_reset_deassert(struct clk *c);
187 void tegra2_periph_reset_assert(struct clk *c);
188 void clk_init(struct clk *clk);
189 struct clk *tegra_get_clock_by_name(const char *name);
190 unsigned long clk_measure_input_freq(void);
191 int clk_reparent(struct clk *c, struct clk *parent);
192 void tegra_clk_init_from_table(struct tegra_clk_init_table *table);
193 void clk_set_cansleep(struct clk *c);
194 unsigned long clk_get_rate_locked(struct clk *c);
195 int clk_set_rate_locked(struct clk *c, unsigned long rate);
196 void tegra2_sdmmc_tap_delay(struct clk *c, int delay);
197 int tegra_emc_set_rate(unsigned long rate);
198 long tegra_emc_round_rate(unsigned long rate);
199 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value);
200
201 static inline bool clk_is_auto_dvfs(struct clk *c)
202 {
203         return c->auto_dvfs;
204 }
205
206 static inline bool clk_is_dvfs(struct clk *c)
207 {
208         return (c->dvfs != NULL);
209 }
210
211 static inline bool clk_cansleep(struct clk *c)
212 {
213         return c->cansleep;
214 }
215
216 static inline void clk_lock_save(struct clk *c, unsigned long *flags)
217 {
218         if (clk_cansleep(c)) {
219                 *flags = 0;
220                 mutex_lock(&c->mutex);
221         } else {
222                 spin_lock_irqsave(&c->spinlock, *flags);
223         }
224 }
225
226 static inline void clk_unlock_restore(struct clk *c, unsigned long *flags)
227 {
228         if (clk_cansleep(c))
229                 mutex_unlock(&c->mutex);
230         else
231                 spin_unlock_irqrestore(&c->spinlock, *flags);
232 }
233
234 static inline void clk_lock_init(struct clk *c)
235 {
236         mutex_init(&c->mutex);
237         spin_lock_init(&c->spinlock);
238 }
239
240 #ifdef CONFIG_CPU_FREQ
241 struct cpufreq_frequency_table;
242
243 struct tegra_cpufreq_table_data {
244         struct cpufreq_frequency_table *freq_table;
245         int throttle_lowest_index;
246         int throttle_highest_index;
247 };
248 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void);
249 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate);
250 #endif
251
252 #endif
253 #endif