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