rtc: tps80031: register as mfd sub device
[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 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
26 #define USE_PLL_LOCK_BITS 0     /* Never use lock bits on Tegra2 */
27 #else
28 #define USE_PLL_LOCK_BITS 1     /* Use lock bits for PLL stabiliation */
29 #define USE_PLLE_SS 1           /* Use spread spectrum coefficients for PLLE */
30 #define PLL_POST_LOCK_DELAY 50  /* Safety delay after lock is detected */
31 #endif
32
33 #define DIV_BUS                 (1 << 0)
34 #define DIV_U71                 (1 << 1)
35 #define DIV_U71_FIXED           (1 << 2)
36 #define DIV_2                   (1 << 3)
37 #define DIV_U16                 (1 << 4)
38 #define PLL_FIXED               (1 << 5)
39 #define PLL_HAS_CPCON           (1 << 6)
40 #define MUX                     (1 << 7)
41 #define PLLD                    (1 << 8)
42 #define PERIPH_NO_RESET         (1 << 9)
43 #define PERIPH_NO_ENB           (1 << 10)
44 #define PERIPH_EMC_ENB          (1 << 11)
45 #define PERIPH_MANUAL_RESET     (1 << 12)
46 #define PLL_ALT_MISC_REG        (1 << 13)
47 #define PLLU                    (1 << 14)
48 #define PLLX                    (1 << 15)
49 #define MUX_PWM                 (1 << 16)
50 #define MUX8                    (1 << 17)
51 #define DIV_U151_UART           (1 << 18)
52 #define MUX_CLK_OUT             (1 << 19)
53 #define PLLM                    (1 << 20)
54 #define DIV_U71_INT             (1 << 21)
55 #define DIV_U71_IDLE            (1 << 22)
56 #define DIV_U151                (1 << 23)
57 #define ENABLE_ON_INIT          (1 << 28)
58 #define PERIPH_ON_APB           (1 << 29)
59 #define PERIPH_ON_CBUS          (1 << 30)
60
61 #ifndef __ASSEMBLY__
62
63 #include <linux/clkdev.h>
64 #include <linux/list.h>
65 #include <linux/mutex.h>
66 #include <linux/spinlock.h>
67 #include <asm/cputime.h>
68
69 #include <mach/clk.h>
70 #define MAX_SAME_LIMIT_SKU_IDS  16
71
72 struct clk;
73
74 struct clk_mux_sel {
75         struct clk      *input;
76         u32             value;
77 };
78
79 struct clk_backup {
80         struct clk      *input;
81         u32             value;
82         unsigned long   bus_rate;
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 struct clk_ops {
95         void            (*init)(struct clk *);
96         int             (*enable)(struct clk *);
97         void            (*disable)(struct clk *);
98         int             (*set_parent)(struct clk *, struct clk *);
99         int             (*set_rate)(struct clk *, unsigned long);
100         long            (*round_rate)(struct clk *, unsigned long);
101         int             (*clk_cfg_ex)(struct clk *, enum tegra_clk_ex_param, u32);
102         void            (*reset)(struct clk *, bool);
103         int             (*shared_bus_update)(struct clk *);
104 };
105
106 struct clk_stats {
107         cputime64_t     time_on;
108         u64             last_update;
109 };
110
111 enum cpu_mode {
112         MODE_G = 0,
113         MODE_LP,
114 };
115
116 enum shared_bus_users_mode {
117         SHARED_FLOOR = 0,
118         SHARED_BW,
119         SHARED_CEILING,
120         SHARED_AUTO,
121 };
122
123 enum clk_state {
124         UNINITIALIZED = 0,
125         ON,
126         OFF,
127 };
128
129 struct clk {
130         /* node for master clocks list */
131         struct list_head        node;           /* node for list of all clocks */
132         struct dvfs             *dvfs;
133         struct clk_lookup       lookup;
134
135 #ifdef CONFIG_DEBUG_FS
136         struct dentry           *dent;
137 #endif
138         bool                    set;
139         struct clk_ops          *ops;
140         unsigned long           dvfs_rate;
141         unsigned long           rate;
142         unsigned long           max_rate;
143         unsigned long           min_rate;
144         bool                    auto_dvfs;
145         bool                    cansleep;
146         u32                     flags;
147         const char              *name;
148
149         u32                     refcnt;
150         enum clk_state          state;
151         struct clk              *parent;
152         u32                     div;
153         u32                     mul;
154         struct clk_stats        stats;
155
156         const struct clk_mux_sel        *inputs;
157         u32                             reg;
158         u32                             reg_shift;
159
160         struct list_head                shared_bus_list;
161         struct clk_backup               shared_bus_backup;
162
163         union {
164                 struct {
165                         unsigned int                    clk_num;
166                 } periph;
167                 struct {
168                         unsigned long                   input_min;
169                         unsigned long                   input_max;
170                         unsigned long                   cf_min;
171                         unsigned long                   cf_max;
172                         unsigned long                   vco_min;
173                         unsigned long                   vco_max;
174                         const struct clk_pll_freq_table *freq_table;
175                         int                             lock_delay;
176                         unsigned long                   fixed_rate;
177                 } pll;
178                 struct {
179                         unsigned long                   default_rate;
180                 } pll_div;
181                 struct {
182                         u32                             sel;
183                         u32                             reg_mask;
184                 } mux;
185                 struct {
186                         struct clk                      *main;
187                         struct clk                      *backup;
188                         unsigned long                   backup_rate;
189                         enum cpu_mode                   mode;
190                 } cpu;
191                 struct {
192                         u32                             div71;
193                 } cclk;
194                 struct {
195                         struct clk                      *pclk;
196                         struct clk                      *hclk;
197                         struct clk                      *sclk_low;
198                         struct clk                      *sclk_high;
199                         unsigned long                   threshold;
200                 } system;
201                 struct {
202                         struct list_head                node;
203                         bool                            enabled;
204                         unsigned long                   rate;
205                         const char                      *client_id;
206                         struct clk                      *client;
207                         u32                             client_div;
208                         enum shared_bus_users_mode      mode;
209                 } shared_bus_user;
210         } u;
211
212         struct raw_notifier_head                        *rate_change_nh;
213
214         struct mutex mutex;
215         spinlock_t spinlock;
216 };
217
218 struct clk_duplicate {
219         const char *name;
220         struct clk_lookup lookup;
221 };
222
223 struct tegra_clk_init_table {
224         const char *name;
225         const char *parent;
226         unsigned long rate;
227         bool enabled;
228 };
229
230 struct tegra_sku_rate_limit {
231         const char *clk_name;
232         unsigned long max_rate;
233         int sku_ids[MAX_SAME_LIMIT_SKU_IDS];
234 };
235
236 void tegra_soc_init_clocks(void);
237 void tegra_init_max_rate(struct clk *c, unsigned long max_rate);
238 void clk_init(struct clk *clk);
239 struct clk *tegra_get_clock_by_name(const char *name);
240 unsigned long tegra_clk_measure_input_freq(void);
241 int clk_reparent(struct clk *c, struct clk *parent);
242 void tegra_clk_init_from_table(struct tegra_clk_init_table *table);
243 void clk_set_cansleep(struct clk *c);
244 unsigned long clk_get_max_rate(struct clk *c);
245 unsigned long clk_get_min_rate(struct clk *c);
246 unsigned long clk_get_rate_locked(struct clk *c);
247 int clk_set_rate_locked(struct clk *c, unsigned long rate);
248 int clk_set_parent_locked(struct clk *c, struct clk *parent);
249 long clk_round_rate_locked(struct clk *c, unsigned long rate);
250 int tegra_clk_shared_bus_update(struct clk *c);
251 void tegra2_sdmmc_tap_delay(struct clk *c, int delay);
252 void tegra3_set_cpu_skipper_delay(int delay);
253 int tegra_emc_set_rate(unsigned long rate);
254 long tegra_emc_round_rate(unsigned long rate);
255 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value);
256 void tegra_emc_timing_invalidate(void);
257 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
258 static inline int tegra_emc_backup(unsigned long rate)
259 { return 0; }
260 static inline bool tegra_clk_is_parent_allowed(struct clk *c, struct clk *p)
261 { return true; }
262 #else
263 int tegra_emc_backup(unsigned long rate);
264 bool tegra_clk_is_parent_allowed(struct clk *c, struct clk *p);
265 #endif
266
267 static inline bool clk_is_auto_dvfs(struct clk *c)
268 {
269         return c->auto_dvfs;
270 }
271
272 static inline bool clk_is_dvfs(struct clk *c)
273 {
274         return (c->dvfs != NULL);
275 }
276
277 static inline bool clk_cansleep(struct clk *c)
278 {
279         return c->cansleep;
280 }
281
282 static inline void clk_lock_save(struct clk *c, unsigned long *flags)
283 {
284         if (clk_cansleep(c)) {
285                 *flags = 0;
286                 mutex_lock(&c->mutex);
287         } else {
288                 spin_lock_irqsave(&c->spinlock, *flags);
289         }
290 }
291
292 static inline void clk_unlock_restore(struct clk *c, unsigned long *flags)
293 {
294         if (clk_cansleep(c))
295                 mutex_unlock(&c->mutex);
296         else
297                 spin_unlock_irqrestore(&c->spinlock, *flags);
298 }
299
300 static inline void clk_lock_init(struct clk *c)
301 {
302         mutex_init(&c->mutex);
303         spin_lock_init(&c->spinlock);
304 }
305
306 #ifdef CONFIG_CPU_FREQ
307 struct cpufreq_frequency_table;
308
309 struct tegra_cpufreq_table_data {
310         struct cpufreq_frequency_table *freq_table;
311         int throttle_lowest_index;
312         int throttle_highest_index;
313         int suspend_index;
314 };
315 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void);
316 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate);
317 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
318 static inline int tegra_update_mselect_rate(unsigned long cpu_rate)
319 { return 0; }
320 #else
321 int tegra_update_mselect_rate(unsigned long cpu_rate);
322 #endif
323 #endif
324
325 #endif
326 #endif