ARM: tegra: clock: Add Tegra3 emc high voltage bridge
[linux-3.10.git] / arch / arm / mach-tegra / tegra3_emc.c
1 /*
2  * arch/arm/mach-tegra/tegra3_emc.c
3  *
4  * Copyright (C) 2011 NVIDIA Corporation
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19  *
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/clk.h>
24 #include <linux/err.h>
25 #include <linux/io.h>
26 #include <linux/module.h>
27 #include <linux/delay.h>
28 #include <linux/platform_device.h>
29 #include <linux/platform_data/tegra30_emc.h>
30 #include <linux/debugfs.h>
31 #include <linux/seq_file.h>
32
33 #include <asm/cputime.h>
34
35 #include <mach/iomap.h>
36
37 #include "clock.h"
38 #include "dvfs.h"
39 #include "tegra3_emc.h"
40
41 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
42 static bool emc_enable = true;
43 #else
44 static bool emc_enable;
45 #endif
46 module_param(emc_enable, bool, 0644);
47
48 static struct platform_device *emc_pdev;
49 static void __iomem *emc_regbases[2];
50
51 #define EMC_STATUS_UPDATE_TIMEOUT       100
52 #define TEGRA_EMC_TABLE_MAX_SIZE        16
53
54 enum {
55         DLL_CHANGE_NONE = 0,
56         DLL_CHANGE_ON,
57         DLL_CHANGE_OFF,
58 };
59
60 #define EMC_CLK_DIV_SHIFT               0
61 #define EMC_CLK_DIV_MASK                (0xFF << EMC_CLK_DIV_SHIFT)
62 #define EMC_CLK_SOURCE_SHIFT            30
63 #define EMC_CLK_SOURCE_MASK             (0x3 << EMC_CLK_SOURCE_SHIFT)
64 #define EMC_CLK_LOW_JITTER_ENABLE       (0x1 << 29)
65 #define EMC_CLK_MC_SAME_FREQ            (0x1 << 16)
66
67 #define BURST_REG_LIST \
68         DEFINE_REG(TEGRA_EMC_BASE, EMC_RC)                      \
69         DEFINE_REG(TEGRA_EMC_BASE, EMC_RFC)                     \
70         DEFINE_REG(TEGRA_EMC_BASE, EMC_RAS)                     \
71         DEFINE_REG(TEGRA_EMC_BASE, EMC_RP)                      \
72         DEFINE_REG(TEGRA_EMC_BASE, EMC_R2W)                     \
73         DEFINE_REG(TEGRA_EMC_BASE, EMC_W2R)                     \
74         DEFINE_REG(TEGRA_EMC_BASE, EMC_R2P)                     \
75         DEFINE_REG(TEGRA_EMC_BASE, EMC_W2P)                     \
76         DEFINE_REG(TEGRA_EMC_BASE, EMC_RD_RCD)                  \
77         DEFINE_REG(TEGRA_EMC_BASE, EMC_WR_RCD)                  \
78         DEFINE_REG(TEGRA_EMC_BASE, EMC_RRD)                     \
79         DEFINE_REG(TEGRA_EMC_BASE, EMC_REXT)                    \
80         DEFINE_REG(TEGRA_EMC_BASE, EMC_WEXT)                    \
81         DEFINE_REG(TEGRA_EMC_BASE, EMC_WDV)                     \
82         DEFINE_REG(TEGRA_EMC_BASE, EMC_QUSE)                    \
83         DEFINE_REG(TEGRA_EMC_BASE, EMC_QRST)                    \
84         DEFINE_REG(TEGRA_EMC_BASE, EMC_QSAFE)                   \
85         DEFINE_REG(TEGRA_EMC_BASE, EMC_RDV)                     \
86         DEFINE_REG(TEGRA_EMC_BASE, EMC_REFRESH)                 \
87         DEFINE_REG(TEGRA_EMC_BASE, EMC_BURST_REFRESH_NUM)       \
88         DEFINE_REG(TEGRA_EMC_BASE, EMC_PRE_REFRESH_REQ_CNT)     \
89         DEFINE_REG(TEGRA_EMC_BASE, EMC_PDEX2WR)                 \
90         DEFINE_REG(TEGRA_EMC_BASE, EMC_PDEX2RD)                 \
91         DEFINE_REG(TEGRA_EMC_BASE, EMC_PCHG2PDEN)               \
92         DEFINE_REG(TEGRA_EMC_BASE, EMC_ACT2PDEN)                \
93         DEFINE_REG(TEGRA_EMC_BASE, EMC_AR2PDEN)                 \
94         DEFINE_REG(TEGRA_EMC_BASE, EMC_RW2PDEN)                 \
95         DEFINE_REG(TEGRA_EMC_BASE, EMC_TXSR)                    \
96         DEFINE_REG(TEGRA_EMC_BASE, EMC_TXSRDLL)                 \
97         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCKE)                    \
98         DEFINE_REG(TEGRA_EMC_BASE, EMC_TFAW)                    \
99         DEFINE_REG(TEGRA_EMC_BASE, EMC_TRPAB)                   \
100         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCLKSTABLE)              \
101         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCLKSTOP)                \
102         DEFINE_REG(TEGRA_EMC_BASE, EMC_TREFBW)                  \
103         DEFINE_REG(TEGRA_EMC_BASE, EMC_QUSE_EXTRA)              \
104         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_CFG6)               \
105         DEFINE_REG(TEGRA_EMC_BASE, EMC_ODT_WRITE)               \
106         DEFINE_REG(TEGRA_EMC_BASE, EMC_ODT_READ)                \
107         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_CFG5)               \
108         DEFINE_REG(TEGRA_EMC_BASE, EMC_CFG_DIG_DLL)             \
109         DEFINE_REG(TEGRA_EMC_BASE, EMC_CFG_DIG_DLL_PERIOD)      \
110         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS0)          \
111         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS1)          \
112         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS2)          \
113         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS3)          \
114         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS4)          \
115         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS5)          \
116         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS6)          \
117         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS7)          \
118         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE0)         \
119         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE1)         \
120         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE2)         \
121         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE3)         \
122         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE4)         \
123         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE5)         \
124         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE6)         \
125         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE7)         \
126         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS0)         \
127         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS1)         \
128         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS2)         \
129         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS3)         \
130         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS4)         \
131         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS5)         \
132         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS6)         \
133         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS7)         \
134         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ0)           \
135         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ1)           \
136         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ2)           \
137         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ3)           \
138         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2CMDPADCTRL)           \
139         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQSPADCTRL2)          \
140         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQPADCTRL2)           \
141         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2CLKPADCTRL)           \
142         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2COMPPADCTRL)          \
143         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2VTTGENPADCTRL)        \
144         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2VTTGENPADCTRL2)       \
145         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2QUSEPADCTRL)          \
146         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQSPADCTRL3)          \
147         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT_TERM_CTRL)           \
148         DEFINE_REG(TEGRA_EMC_BASE, EMC_ZCAL_INTERVAL)           \
149         DEFINE_REG(TEGRA_EMC_BASE, EMC_ZCAL_WAIT_CNT)           \
150         DEFINE_REG(TEGRA_EMC_BASE, EMC_MRS_WAIT_CNT)            \
151         DEFINE_REG(TEGRA_EMC_BASE, EMC_AUTO_CAL_CONFIG)         \
152         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT)                     \
153         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT_DURATION)            \
154         DEFINE_REG(TEGRA_EMC_BASE, EMC_DYN_SELF_REF_CONTROL)    \
155                                                                 \
156         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_CFG)              \
157         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_OUTSTANDING_REQ)  \
158         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RCD)       \
159         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RP)        \
160         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RC)        \
161         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RAS)       \
162         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_FAW)       \
163         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RRD)       \
164         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RAP2PRE)   \
165         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_WAP2PRE)   \
166         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_R2R)       \
167         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_W2W)       \
168         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_R2W)       \
169         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_W2R)       \
170         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_DA_TURNS)         \
171         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_DA_COVERS)        \
172         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_MISC0)            \
173         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_RING1_THROTTLE)
174
175 #define DEFINE_REG(base, reg)   (IO_ADDRESS((base)) + (reg)),
176 static const void __iomem *burst_reg_addr[TEGRA_EMC_NUM_REGS] = {
177         BURST_REG_LIST
178 };
179 #undef DEFINE_REG
180
181 #define DEFINE_REG(base, reg)   reg##_INDEX,
182 enum {
183         BURST_REG_LIST
184 };
185 #undef DEFINE_REG
186
187 static struct clk_mux_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
188 static int emc_last_sel;
189 static struct tegra_emc_table start_timing;
190 static bool emc_timing_in_sync;
191
192 static u32 dram_type;
193 static u32 dram_dev_num;
194 static u32 emc_cfg_saved;
195
196 static struct clk *emc;
197
198 static struct {
199         cputime64_t time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE];
200         u64 last_update;
201         u64 clkchange_count;
202         spinlock_t spinlock;
203 } emc_stats;
204
205 static void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
206
207 static inline void emc_writel(int bank, u32 val, unsigned long addr)
208 {
209         writel(val, emc_regbases[bank] + addr);
210         barrier();
211 }
212 static inline u32 emc_readl(int bank, unsigned long addr)
213 {
214         return readl(emc_regbases[bank] + addr);
215 }
216
217 static void emc_last_stats_update(int last_sel)
218 {
219         unsigned long flags;
220         u64 cur_jiffies = get_jiffies_64();
221
222         spin_lock_irqsave(&emc_stats.spinlock, flags);
223
224         emc_stats.time_at_clock[emc_last_sel] =
225                 emc_stats.time_at_clock[emc_last_sel] +
226                         (cur_jiffies - emc_stats.last_update);
227
228         emc_stats.last_update = cur_jiffies;
229
230         if (last_sel < TEGRA_EMC_TABLE_MAX_SIZE) {
231                 emc_stats.clkchange_count++;
232                 emc_last_sel = last_sel;
233         }
234         spin_unlock_irqrestore(&emc_stats.spinlock, flags);
235 }
236
237 static int wait_for_update(u32 status_reg, u32 bit_mask, bool updated_state)
238 {
239         int i;
240         for (i = 0; i < EMC_STATUS_UPDATE_TIMEOUT; i++) {
241                 if (!!(emc_readl(status_reg) & bit_mask) == updated_state)
242                         return 0;
243                 udelay(1);
244         }
245         return -ETIMEDOUT;
246 }
247
248 static inline void emc_timing_update(void)
249 {
250         int err;
251
252         emc_writel(0x1, EMC_TIMING_CONTROL);
253         err = wait_for_update(EMC_STATUS,
254                               EMC_STATUS_TIMING_UPDATE_STALLED, false);
255         if (err) {
256                 pr_err("%s: timing update error: %d", __func__, err);
257                 BUG();
258         }
259 }
260
261 static inline void auto_cal_disable(void)
262 {
263         int err;
264
265         emc_writel(0, EMC_AUTO_CAL_INTERVAL);
266         err = wait_for_update(EMC_AUTO_CAL_STATUS,
267                               EMC_AUTO_CAL_STATUS_ACTIVE, false);
268         if (err) {
269                 pr_err("%s: disable auto-cal error: %d", __func__, err);
270                 BUG();
271         }
272 }
273
274 static inline bool dqs_preset(const struct tegra_emc_table *next_timing,
275                               const struct tegra_emc_table *last_timing)
276 {
277         bool ret = false;
278
279 #define DQS_SET(reg, bit)                                                     \
280         do {                                                                  \
281                 if ((next_timing->burst_regs[EMC_##reg##_INDEX] &             \
282                      EMC_##reg##_##bit##_ENABLE) &&                           \
283                     (!(last_timing->burst_regs[EMC_##reg##_INDEX] &           \
284                        EMC_##reg##_##bit##_ENABLE)))   {                      \
285                         emc_writel(last_timing->burst_regs[EMC_##reg##_INDEX] \
286                                    | EMC_##reg##_##bit##_ENABLE, EMC_##reg);  \
287                         ret = true;                                           \
288                 }                                                             \
289         } while (0)
290
291         DQS_SET(XM2DQSPADCTRL2, VREF);
292         DQS_SET(XM2DQSPADCTRL3, VREF);
293         DQS_SET(XM2QUSEPADCTRL, IVREF);
294
295         return ret;
296 }
297
298 static inline void overwrite_mrs_wait_cnt(
299         const struct tegra_emc_table *next_timing,
300         bool zcal_long)
301 {
302         u32 reg;
303         u32 cnt = 512;
304
305         /* For ddr3 when DLL is re-started: overwrite EMC DFS table settings
306            for MRS_WAIT_LONG with maximum of MRS_WAIT_SHORT settings and
307            expected operation length. Reduce the latter by the overlapping
308            zq-calibration, if any */
309         if (zcal_long)
310                 cnt -= dram_dev_num * 256;
311
312         reg = (next_timing->burst_regs[EMC_MRS_WAIT_CNT_INDEX] &
313                 EMC_MRS_WAIT_CNT_SHORT_WAIT_MASK) >>
314                 EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT;
315         if (cnt < reg)
316                 cnt = reg;
317
318         reg = (next_timing->burst_regs[EMC_MRS_WAIT_CNT_INDEX] &
319                 (~EMC_MRS_WAIT_CNT_LONG_WAIT_MASK));
320         reg |= (cnt << EMC_MRS_WAIT_CNT_LONG_WAIT_SHIFT) &
321                 EMC_MRS_WAIT_CNT_LONG_WAIT_MASK;
322
323         emc_writel(reg, EMC_MRS_WAIT_CNT);
324 }
325
326 static inline bool need_qrst(const struct tegra_emc_table *next_timing,
327                              const struct tegra_emc_table *last_timing,
328                              u32 emc_dpd_reg)
329 {
330         u32 last_mode = (last_timing->burst_regs[EMC_FBIO_CFG5_INDEX] &
331                 EMC_CFG5_QUSE_MODE_MASK) >> EMC_CFG5_QUSE_MODE_SHIFT;
332         u32 next_mode = (next_timing->burst_regs[EMC_FBIO_CFG5_INDEX] &
333                 EMC_CFG5_QUSE_MODE_MASK) >> EMC_CFG5_QUSE_MODE_SHIFT;
334
335         /* QUSE DPD is disabled */
336         bool ret = !(emc_dpd_reg & EMC_SEL_DPD_CTRL_QUSE_DPD_ENABLE) &&
337
338         /* QUSE uses external mode before or after clock change */
339                 (((last_mode != EMC_CFG5_QUSE_MODE_PULSE_INTERN) &&
340                   (last_mode != EMC_CFG5_QUSE_MODE_INTERNAL_LPBK)) ||
341                  ((next_mode != EMC_CFG5_QUSE_MODE_PULSE_INTERN) &&
342                   (next_mode != EMC_CFG5_QUSE_MODE_INTERNAL_LPBK)))  &&
343
344         /* QUSE pad switches from schmitt to vref mode */
345                 (((last_timing->burst_regs[EMC_XM2QUSEPADCTRL_INDEX] &
346                    EMC_XM2QUSEPADCTRL_IVREF_ENABLE) == 0) &&
347                  ((next_timing->burst_regs[EMC_XM2QUSEPADCTRL_INDEX] &
348                    EMC_XM2QUSEPADCTRL_IVREF_ENABLE) != 0));
349
350         return ret;
351 }
352
353 static inline void periodic_qrst_enable(u32 emc_cfg_reg, u32 emc_dbg_reg)
354 {
355         /* enable write mux => enable periodic QRST => restore mux */
356         emc_writel(emc_dbg_reg | EMC_DBG_WRITE_MUX_ACTIVE, EMC_DBG);
357         emc_writel(emc_cfg_reg | EMC_CFG_PERIODIC_QRST, EMC_CFG);
358         emc_writel(emc_dbg_reg, EMC_DBG);
359 }
360
361 static inline void periodic_qrst_restore(u32 emc_cfg_reg, u32 emc_dbg_reg)
362 {
363         /* enable write mux => restore periodic QRST => restore mux */
364         emc_writel(emc_dbg_reg | EMC_DBG_WRITE_MUX_ACTIVE, EMC_DBG);
365         emc_writel(emc_cfg_reg, EMC_CFG);
366         emc_writel(emc_dbg_reg, EMC_DBG);
367 }
368
369 static inline int get_dll_change(const struct tegra_emc_table *next_timing,
370                                  const struct tegra_emc_table *last_timing)
371 {
372         bool next_dll_enabled = !(next_timing->emc_mode_1 & 0x1);
373         bool last_dll_enabled = !(last_timing->emc_mode_1 & 0x1);
374
375         if (next_dll_enabled == last_dll_enabled)
376                 return DLL_CHANGE_NONE;
377         else if (next_dll_enabled)
378                 return DLL_CHANGE_ON;
379         else
380                 return DLL_CHANGE_OFF;
381 }
382
383 static inline void set_dram_mode(const struct tegra_emc_table *next_timing,
384                                  const struct tegra_emc_table *last_timing,
385                                  int dll_change)
386 {
387         if (dram_type == DRAM_TYPE_DDR3) {
388                 /* first mode_1, then mode_2, then mode_reset*/
389                 if (next_timing->emc_mode_1 != last_timing->emc_mode_1)
390                         emc_writel(next_timing->emc_mode_1, EMC_EMRS);
391                 if (next_timing->emc_mode_2 != last_timing->emc_mode_2)
392                         emc_writel(next_timing->emc_mode_2, EMC_EMRS);
393
394                 if ((next_timing->emc_mode_reset !=
395                      last_timing->emc_mode_reset) ||
396                     (dll_change == DLL_CHANGE_ON))
397                 {
398                         u32 reg = next_timing->emc_mode_reset &
399                                 (~EMC_MODE_SET_DLL_RESET);
400                         if (dll_change == DLL_CHANGE_ON) {
401                                 reg |= EMC_MODE_SET_DLL_RESET;
402                                 reg |= EMC_MODE_SET_LONG_CNT;
403                         }
404                         emc_writel(reg, EMC_MRS);
405                 }
406         } else {
407                 /* first mode_2, then mode_1; mode_reset is not applicable */
408                 if (next_timing->emc_mode_2 != last_timing->emc_mode_2)
409                         emc_writel(next_timing->emc_mode_2, EMC_MRW);
410                 if (next_timing->emc_mode_1 != last_timing->emc_mode_1)
411                         emc_writel(next_timing->emc_mode_1, EMC_MRW);
412         }
413 }
414
415 static inline void do_clock_change(u32 clk_setting)
416 {
417         int err;
418
419         mc_readl(MC_EMEM_ADR_CFG);      /* completes prev writes */
420         writel(clk_setting, clk_base + emc->reg);
421
422         err = wait_for_update(EMC_INTSTATUS,
423                               EMC_INTSTATUS_CLKCHANGE_COMPLETE, true);
424         if (err) {
425                 pr_err("%s: clock change completion error: %d", __func__, err);
426                 BUG();
427         }
428 }
429
430 static noinline void emc_set_clock(const struct tegra_emc_table *next_timing,
431                                    const struct tegra_emc_table *last_timing,
432                                    u32 clk_setting)
433 {
434         int i, dll_change, pre_wait;
435         bool dyn_sref_enabled, vref_cal_toggle, qrst_used, zcal_long;
436
437         u32 emc_cfg_reg = emc_readl(EMC_CFG);
438         u32 emc_dbg_reg = emc_readl(EMC_DBG);
439
440         dyn_sref_enabled = emc_cfg_reg & EMC_CFG_DYN_SREF_ENABLE;
441         dll_change = get_dll_change(next_timing, last_timing);
442         zcal_long = (next_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] != 0) &&
443                 (last_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] == 0);
444
445         /* FIXME: remove steps enumeration below? */
446
447         /* 1. clear clkchange_complete interrupts */
448         emc_writel(EMC_INTSTATUS_CLKCHANGE_COMPLETE, EMC_INTSTATUS);
449
450         /* 2. disable dynamic self-refresh and preset dqs vref, then wait for
451            possible self-refresh entry/exit and/or dqs vref settled - waiting
452            before the clock change decreases worst case change stall time */
453         pre_wait = 0;
454         if (dyn_sref_enabled) {
455                 emc_cfg_reg &= ~EMC_CFG_DYN_SREF_ENABLE;
456                 emc_writel(emc_cfg_reg, EMC_CFG);
457                 pre_wait = 5;           /* 5us+ for self-refresh entry/exit */
458         }
459         if (dqs_preset(next_timing, last_timing)) {
460                 if (pre_wait < 3)
461                         pre_wait = 3;   /* 3us+ for dqs vref settled */
462         }
463         if (pre_wait) {
464                 emc_timing_update();
465                 udelay(pre_wait);
466         }
467
468         /* 3. disable auto-cal if vref mode is switching */
469         vref_cal_toggle = (next_timing->emc_acal_interval != 0) &&
470                 ((next_timing->burst_regs[EMC_XM2COMPPADCTRL_INDEX] ^
471                   last_timing->burst_regs[EMC_XM2COMPPADCTRL_INDEX]) &
472                  EMC_XM2COMPPADCTRL_VREF_CAL_ENABLE);
473         if (vref_cal_toggle)
474                 auto_cal_disable();
475
476         /* 4. program burst shadow registers */
477         for (i = 0; i < TEGRA_EMC_NUM_REGS; i++)
478                 __raw_writel(next_timing->burst_regs[i], burst_reg_addr[i]);
479         wmb();
480         barrier();
481
482         /* On ddr3 when DLL is re-started predict MRS long wait count and
483            overwrite DFS table setting */
484         if ((dram_type == DRAM_TYPE_DDR3) && (dll_change == DLL_CHANGE_ON))
485                 overwrite_mrs_wait_cnt(next_timing, zcal_long);
486
487         /* the last read below makes sure prev writes are completed */
488         qrst_used = need_qrst(next_timing, last_timing,
489                               emc_readl(EMC_SEL_DPD_CTRL));
490
491         /* 5. flow control marker 1 (no EMC read access after this) */
492         emc_writel(1, EMC_STALL_BEFORE_CLKCHANGE);
493
494         /* 6. enable periodic QRST */
495         if (qrst_used)
496                 periodic_qrst_enable(emc_cfg_reg, emc_dbg_reg);
497
498         /* 6.1 disable auto-refresh to save time after clock change */
499         emc_writel(EMC_REFCTRL_DISABLE_ALL(dram_dev_num), EMC_REFCTRL);
500
501         /* 7. turn Off dll and enter self-refresh on DDR3 */
502         if (dram_type == DRAM_TYPE_DDR3) {
503                 if (dll_change == DLL_CHANGE_OFF)
504                         emc_writel(next_timing->emc_mode_1, EMC_EMRS);
505                 emc_writel(DRAM_BROADCAST(dram_dev_num) |
506                            EMC_SELF_REF_CMD_ENABLED, EMC_SELF_REF);
507         }
508
509         /* 8. flow control marker 2 */
510         emc_writel(1, EMC_STALL_AFTER_CLKCHANGE);
511
512         /* 9. exit self-refresh on DDR3 */
513         if (dram_type == DRAM_TYPE_DDR3)
514                 emc_writel(DRAM_BROADCAST(dram_dev_num), EMC_SELF_REF);
515
516         /* 10. restore periodic QRST */
517         if ((qrst_used) || (next_timing->emc_periodic_qrst !=
518                             last_timing->emc_periodic_qrst)) {
519                 emc_cfg_reg = next_timing->emc_periodic_qrst ?
520                         emc_cfg_reg | EMC_CFG_PERIODIC_QRST :
521                         emc_cfg_reg & (~EMC_CFG_PERIODIC_QRST);
522                 periodic_qrst_restore(emc_cfg_reg, emc_dbg_reg);
523         }
524
525         /* 11. set dram mode registers */
526         set_dram_mode(next_timing, last_timing, dll_change);
527
528         /* 12. issue zcal command if turning zcal On */
529         if (zcal_long) {
530                 emc_writel(EMC_ZQ_CAL_LONG_CMD_DEV0, EMC_ZQ_CAL);
531                 if (dram_dev_num > 1)
532                         emc_writel(EMC_ZQ_CAL_LONG_CMD_DEV1, EMC_ZQ_CAL);
533         }
534
535         /* 13. flow control marker 3 */
536         emc_writel(1, EMC_UNSTALL_RW_AFTER_CLKCHANGE);
537
538         /* 14. read any MC register to ensure the programming is done
539                change EMC clock source register (EMC read access restored)
540                wait for clk change completion */
541         do_clock_change(clk_setting);
542
543         /* 14.1 re-enable auto-refresh */
544         emc_writel(EMC_REFCTRL_ENABLE_ALL(dram_dev_num), EMC_REFCTRL);
545
546         /* 15. restore auto-cal */
547         if (vref_cal_toggle)
548                 emc_writel(next_timing->emc_acal_interval,
549                            EMC_AUTO_CAL_INTERVAL);
550
551         /* 16. restore dynamic self-refresh */
552         if (dyn_sref_enabled) {
553                 emc_cfg_reg |= EMC_CFG_DYN_SREF_ENABLE;
554                 emc_writel(emc_cfg_reg, EMC_CFG);
555         }
556
557         /* 17. set zcal wait count */
558         if (zcal_long)
559                 emc_writel(next_timing->emc_zcal_cnt_long, EMC_ZCAL_WAIT_CNT);
560
561         /* 18. update restored timing */
562         udelay(2);
563         emc_timing_update();
564 }
565
566 static inline void emc_get_timing(struct tegra_emc_table *timing)
567 {
568         int i;
569
570         for (i = 0; i < TEGRA_EMC_NUM_REGS; i++)
571                 timing->burst_regs[i] = __raw_readl(burst_reg_addr[i]);
572         timing->emc_acal_interval = 0;
573         timing->emc_zcal_cnt_long = 0;
574         timing->emc_mode_reset = 0;
575         timing->emc_mode_1 = 0;
576         timing->emc_mode_2 = 0;
577         timing->emc_periodic_qrst = (emc_readl(EMC_CFG) &
578                                      EMC_CFG_PERIODIC_QRST) ? 1 : 0;
579 }
580
581 /* After deep sleep EMC power features are not restored.
582  * Do it at run-time after the 1st clock change.
583  */
584 static inline void emc_cfg_power_restore(void)
585 {
586         u32 reg = emc_readl(EMC_CFG);
587         if ((reg ^ emc_cfg_saved) & EMC_CFG_PWR_MASK) {
588                 reg = (reg & (~EMC_CFG_PWR_MASK)) |
589                         (emc_cfg_saved & EMC_CFG_PWR_MASK);
590                 emc_writel(reg, EMC_CFG);
591                 emc_timing_update();
592         }
593 }
594
595 /* The EMC registers have shadow registers. When the EMC clock is updated
596  * in the clock controller, the shadow registers are copied to the active
597  * registers, allowing glitchless memory bus frequency changes.
598  * This function updates the shadow registers for a new clock frequency,
599  * and relies on the clock lock on the emc clock to avoid races between
600  * multiple frequency changes */
601 int tegra_emc_set_rate(unsigned long rate)
602 {
603         int i;
604         u32 clk_setting;
605         const struct tegra_emc_table *last_timing;
606
607         if (!tegra_emc_table)
608                 return -EINVAL;
609
610         /* Table entries specify rate in kHz */
611         rate = rate / 1000;
612
613         for (i = 0; i < tegra_emc_table_size; i++) {
614                 if (tegra_emc_clk_sel[i].input == NULL)
615                         continue;       /* invalid entry */
616
617                 if (tegra_emc_table[i].rate == rate)
618                         break;
619         }
620
621         if (i >= tegra_emc_table_size)
622                 return -EINVAL;
623
624         if (!emc_timing_in_sync) {
625                 /* can not assume that boot timing matches dfs table even
626                    if boot frequency matches one of the table nodes */
627                 emc_get_timing(&start_timing);
628                 last_timing = &start_timing;
629         }
630         else
631                 last_timing = &tegra_emc_table[emc_last_sel];
632
633         clk_setting = tegra_emc_clk_sel[i].value;
634         emc_set_clock(&tegra_emc_table[i], last_timing, clk_setting);
635         if (!emc_timing_in_sync)
636                 emc_cfg_power_restore();
637         emc_timing_in_sync = true;
638         emc_last_stats_update(i);
639
640         pr_debug("%s: rate %lu setting 0x%x\n", __func__, rate, clk_setting);
641
642         return 0;
643 }
644
645 /* Select the closest EMC rate that is higher than the requested rate */
646 long tegra_emc_round_rate(unsigned long rate)
647 {
648         int i;
649         int best = -1;
650         unsigned long distance = ULONG_MAX;
651
652         if (!tegra_emc_table)
653                 return -EINVAL;
654
655         if (!emc_enable)
656                 return -EINVAL;
657
658         pr_debug("%s: %lu\n", __func__, rate);
659
660         /* Table entries specify rate in kHz */
661         rate = rate / 1000;
662
663         for (i = 0; i < tegra_emc_table_size; i++) {
664                 if (tegra_emc_clk_sel[i].input == NULL)
665                         continue;       /* invalid entry */
666
667                 if (tegra_emc_table[i].rate >= rate &&
668                     (tegra_emc_table[i].rate - rate) < distance) {
669                         distance = tegra_emc_table[i].rate - rate;
670                         best = i;
671                 }
672         }
673
674         if (best < 0)
675                 return -EINVAL;
676
677         pr_debug("%s: using %lu\n", __func__, tegra_emc_table[best].rate);
678
679         return tegra_emc_table[best].rate * 1000;
680 }
681
682 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
683 {
684         int i;
685
686         if (!tegra_emc_table)
687                 return NULL;
688
689         pr_debug("%s: %lu\n", __func__, rate);
690
691         /* Table entries specify rate in kHz */
692         rate = rate / 1000;
693
694         for (i = 0; i < tegra_emc_table_size; i++) {
695                 if (tegra_emc_table[i].rate == rate) {
696                         *div_value = (tegra_emc_clk_sel[i].value &
697                                 EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
698                         return tegra_emc_clk_sel[i].input;
699                 }
700         }
701
702         return NULL;
703 }
704
705 static const struct clk_mux_sel *find_matching_input(
706         unsigned long table_rate,
707         u32 *div_value)
708 {
709         unsigned long inp_rate;
710         const struct clk_mux_sel *sel;
711
712         for (sel = emc->inputs; sel->input != NULL; sel++) {
713                 /* Table entries specify rate in kHz */
714                 inp_rate = clk_get_rate(sel->input) / 1000;
715
716                 if ((inp_rate >= table_rate) &&
717                      (inp_rate % table_rate == 0)) {
718                         *div_value = 2 * inp_rate / table_rate - 2;
719                         return sel;
720                 }
721         }
722         return NULL;
723 }
724
725 static bool is_emc_bridge(void)
726 {
727         int mv;
728         unsigned long rate;
729         struct clk *bridge = tegra_get_clock_by_name("bridge.emc");
730         BUG_ON(!bridge);
731
732         /* LPDDR2 does not need a bridge entry in DFS table: just lock bridge
733            rate at minimum so it won't interfere with emc bus operations */
734         if (dram_type == DRAM_TYPE_LPDDR2) {
735                 clk_set_rate(bridge, 0);
736                 return true;
737         }
738
739         /* DDR3 requires EMC DFS table to include a bridge entry with frequency
740            above minimum bridge threshold, and voltage below bridge threshold */
741         rate = clk_round_rate(bridge, TEGRA_EMC_BRIDGE_RATE_MIN);
742         if (IS_ERR_VALUE(rate))
743                 return false;
744
745         mv = tegra_dvfs_predict_millivolts(emc, rate);
746         if (IS_ERR_VALUE(mv) || (mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN))
747                 return false;
748
749         if (clk_set_rate(bridge, rate))
750                 return false;
751
752         return true;
753 }
754
755 static int tegra_emc_probe(struct platform_device *pdev)
756 {
757         struct tegra_emc_pdata *pdata = NULL;
758         struct resource *res;
759         int i;
760         u32 reg, div_value;
761         bool max_entry = false;
762         unsigned long boot_rate, max_rate;
763         const struct clk_mux_sel *sel;
764
765         emc_cfg_saved = emc_readl(EMC_CFG);
766
767         emc_stats.clkchange_count = 0;
768         spin_lock_init(&emc_stats.spinlock);
769         emc_stats.last_update = get_jiffies_64();
770
771         emc = tegra_get_clock_by_name("emc");
772         BUG_ON(!emc);
773         boot_rate = clk_get_rate(emc) / 1000;
774         max_rate = clk_get_max_rate(emc) / 1000;
775
776         if (emc->parent != tegra_get_clock_by_name("pll_m")) {
777                 pr_warn("tegra: boot parent %s is not supported by EMC DFS\n",
778                         emc->parent->name);
779                 return;
780         }
781
782         if (!emc_enable) {
783                 dev_err(&pdev->dev, "disabled per module parameter\n");
784                 return -ENODEV;
785         }
786
787         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
788         if (!res) {
789                 dev_err(&pdev->dev, "missing register base\n");
790                 return -ENOMEM;
791         }
792
793         emc_regbase = devm_request_and_ioremap(&pdev->dev, res);
794         if (!emc_regbase) {
795                 dev_err(&pdev->dev, "failed to remap registers\n");
796                 return -ENOMEM;
797         }
798
799         pdev->dev.platform_data = pdata;
800
801         emc_pdev = pdev;
802
803         tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
804         for (i = 0; i < tegra_emc_table_size; i++) {
805                 unsigned long table_rate = table[i].rate;
806                 if (!table_rate)
807                         continue;
808
809                 sel = find_matching_input(table_rate, &div_value);
810                 if (!sel)
811                         continue;
812
813                 if (table_rate == boot_rate)
814                         emc_last_sel = i;
815
816                 if (table_rate == max_rate)
817                         max_entry = true;
818
819                 tegra_emc_clk_sel[i] = *sel;
820                 BUG_ON(div_value >
821                        (EMC_CLK_DIV_MASK >> EMC_CLK_DIV_SHIFT));
822                 tegra_emc_clk_sel[i].value <<= EMC_CLK_SOURCE_SHIFT;
823                 tegra_emc_clk_sel[i].value |= (div_value << EMC_CLK_DIV_SHIFT);
824
825                 if ((div_value == 0) &&
826                     (tegra_emc_clk_sel[i].input == emc->parent)) {
827                         tegra_emc_clk_sel[i].value |= EMC_CLK_LOW_JITTER_ENABLE;
828                 }
829
830                 if (table[i].burst_regs[MC_EMEM_ARB_MISC0_INDEX] &
831                     MC_EMEM_ARB_MISC0_EMC_SAME_FREQ)
832                         tegra_emc_clk_sel[i].value |= EMC_CLK_MC_SAME_FREQ;
833         }
834
835         dram_type = (emc_readl(EMC_FBIO_CFG5) &
836                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
837         if ((dram_type != DRAM_TYPE_DDR3) && (dram_type != DRAM_TYPE_LPDDR2)) {
838                 pr_err("Not supported DRAM type %u\n", dram_type);
839                 return;
840         }
841         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
842         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
843                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
844         emc_writel(reg, EMC_CFG_2);
845
846         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
847
848         if (!max_entry) {
849                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
850                        " %lu kHz is not found\n", max_rate);
851                 return;
852         }
853
854         tegra_emc_table = table;
855
856         if (!is_emc_bridge()) {
857                 tegra_emc_table = NULL;
858                 pr_err("tegra: invalid EMC DFS table: emc bridge not found");
859         }
860         pr_info("tegra: validated EMC DFS table\n");
861
862         return 0;
863 }
864
865 static struct platform_driver tegra_emc_driver = {
866         .driver         = {
867                 .name   = "tegra30-emc",
868                 .owner  = THIS_MODULE,
869         },
870         .probe          = tegra_emc_probe,
871 };
872
873 static int __init tegra_init_emc(void)
874 {
875         return platform_driver_register(&tegra_emc_driver);
876 }
877 device_initcall(tegra_emc_init);
878
879 void tegra_emc_timing_invalidate(void)
880 {
881         emc_timing_in_sync = false;
882 }
883
884 #ifdef CONFIG_DEBUG_FS
885
886 static struct dentry *emc_debugfs_root;
887
888 static int emc_stats_show(struct seq_file *s, void *data)
889 {
890         int i;
891
892         emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE);
893
894         seq_printf(s, "%-10s %-10s \n", "rate kHz", "time");
895         for (i = 0; i < tegra_emc_table_size; i++) {
896                 if (tegra_emc_clk_sel[i].input == NULL)
897                         continue;       /* invalid entry */
898
899                 seq_printf(s, "%-10lu %-10llu \n", tegra_emc_table[i].rate,
900                            cputime64_to_clock_t(emc_stats.time_at_clock[i]));
901         }
902         seq_printf(s, "%-15s %llu\n", "transitions:",
903                    emc_stats.clkchange_count);
904         seq_printf(s, "%-15s %llu\n", "time-stamp:",
905                    cputime64_to_clock_t(emc_stats.last_update));
906
907         return 0;
908 }
909
910 static int emc_stats_open(struct inode *inode, struct file *file)
911 {
912         return single_open(file, emc_stats_show, inode->i_private);
913 }
914
915 static const struct file_operations emc_stats_fops = {
916         .open           = emc_stats_open,
917         .read           = seq_read,
918         .llseek         = seq_lseek,
919         .release        = single_release,
920 };
921
922 static int __init tegra_emc_debug_init(void)
923 {
924         if (!tegra_emc_table)
925                 return 0;
926
927         emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL);
928         if (!emc_debugfs_root)
929                 return -ENOMEM;
930
931         if (!debugfs_create_file(
932                 "stats", S_IRUGO, emc_debugfs_root, NULL, &emc_stats_fops))
933                 goto err_out;
934
935         return 0;
936
937 err_out:
938         debugfs_remove_recursive(emc_debugfs_root);
939         return -ENOMEM;
940 }
941
942 late_initcall(tegra_emc_debug_init);
943 #endif