unknown changes from android-tegra-nv-3.4
[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/suspend.h>
29 #include <linux/debugfs.h>
30 #include <linux/seq_file.h>
31
32 #include <asm/cputime.h>
33 #include <asm/cacheflush.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 u8 tegra_emc_bw_efficiency = 35;
49
50 #define EMC_MIN_RATE_DDR3               25500000
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(0             , 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_REG(TEGRA_EMC_BASE, EMC_FBIO_SPARE),             \
176         DEFINE_REG(TEGRA_EMC_BASE, EMC_CFG_RSV),
177
178 #define DEFINE_REG(base, reg) ((base) ? (IO_ADDRESS((base)) + (reg)) : 0)
179 static const void __iomem *burst_reg_addr[TEGRA_EMC_NUM_REGS] = {
180         BURST_REG_LIST
181 };
182 #undef DEFINE_REG
183
184 #define DEFINE_REG(base, reg)   reg##_INDEX
185 enum {
186         BURST_REG_LIST
187 };
188 #undef DEFINE_REG
189
190 static int emc_num_burst_regs;
191
192 static struct clk_mux_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
193 static struct tegra_emc_table start_timing;
194 static const struct tegra_emc_table *emc_timing;
195 static unsigned long dram_over_temp_state = DRAM_OVER_TEMP_NONE;
196
197 static const u32 *dram_to_soc_bit_map;
198 static const struct tegra_emc_table *tegra_emc_table;
199 static int tegra_emc_table_size;
200
201 static u32 dram_dev_num;
202 static u32 emc_cfg_saved;
203 static u32 dram_type = -1;
204
205 static struct clk *emc;
206 static struct clk *bridge;
207
208 static struct {
209         cputime64_t time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE];
210         int last_sel;
211         u64 last_update;
212         u64 clkchange_count;
213         spinlock_t spinlock;
214 } emc_stats;
215
216 static DEFINE_SPINLOCK(emc_access_lock);
217
218 static void __iomem *emc_base = IO_ADDRESS(TEGRA_EMC_BASE);
219 static void __iomem *mc_base = IO_ADDRESS(TEGRA_MC_BASE);
220 static void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
221
222 static inline void emc_writel(u32 val, unsigned long addr)
223 {
224         writel(val, emc_base + addr);
225         barrier();
226 }
227 static inline u32 emc_readl(unsigned long addr)
228 {
229         return readl(emc_base + addr);
230 }
231 static inline void mc_writel(u32 val, unsigned long addr)
232 {
233         writel(val, mc_base + addr);
234         barrier();
235 }
236 static inline u32 mc_readl(unsigned long addr)
237 {
238         return readl(mc_base + addr);
239 }
240
241 static void emc_last_stats_update(int last_sel)
242 {
243         unsigned long flags;
244         u64 cur_jiffies = get_jiffies_64();
245
246         spin_lock_irqsave(&emc_stats.spinlock, flags);
247
248         if (emc_stats.last_sel < TEGRA_EMC_TABLE_MAX_SIZE)
249                 emc_stats.time_at_clock[emc_stats.last_sel] = 
250                         emc_stats.time_at_clock[emc_stats.last_sel] + 
251                         (cur_jiffies - emc_stats.last_update);
252
253         emc_stats.last_update = cur_jiffies;
254
255         if (last_sel < TEGRA_EMC_TABLE_MAX_SIZE) {
256                 emc_stats.clkchange_count++;
257                 emc_stats.last_sel = last_sel;
258         }
259         spin_unlock_irqrestore(&emc_stats.spinlock, flags);
260 }
261
262 static int wait_for_update(u32 status_reg, u32 bit_mask, bool updated_state)
263 {
264         int i;
265         for (i = 0; i < EMC_STATUS_UPDATE_TIMEOUT; i++) {
266                 if (!!(emc_readl(status_reg) & bit_mask) == updated_state)
267                         return 0;
268                 udelay(1);
269         }
270         return -ETIMEDOUT;
271 }
272
273 static inline void emc_timing_update(void)
274 {
275         int err;
276
277         emc_writel(0x1, EMC_TIMING_CONTROL);
278         err = wait_for_update(EMC_STATUS,
279                               EMC_STATUS_TIMING_UPDATE_STALLED, false);
280         if (err) {
281                 pr_err("%s: timing update error: %d", __func__, err);
282                 BUG();
283         }
284 }
285
286 static inline void auto_cal_disable(void)
287 {
288         int err;
289
290         emc_writel(0, EMC_AUTO_CAL_INTERVAL);
291         err = wait_for_update(EMC_AUTO_CAL_STATUS,
292                               EMC_AUTO_CAL_STATUS_ACTIVE, false);
293         if (err) {
294                 pr_err("%s: disable auto-cal error: %d", __func__, err);
295                 BUG();
296         }
297 }
298
299 static inline void set_over_temp_timing(
300         const struct tegra_emc_table *next_timing, unsigned long state)
301 {
302 #define REFRESH_SPEEDUP(val)                                                  \
303         do {                                                                  \
304                 val = ((val) & 0xFFFF0000) | (((val) & 0xFFFF) >> 2);         \
305         } while (0)
306
307         u32 ref = next_timing->burst_regs[EMC_REFRESH_INDEX];
308         u32 pre_ref = next_timing->burst_regs[EMC_PRE_REFRESH_REQ_CNT_INDEX];
309         u32 dsr_cntrl = next_timing->burst_regs[EMC_DYN_SELF_REF_CONTROL_INDEX];
310
311         switch (state) {
312         case DRAM_OVER_TEMP_NONE:
313                 break;
314         case DRAM_OVER_TEMP_REFRESH:
315                 REFRESH_SPEEDUP(ref);
316                 REFRESH_SPEEDUP(pre_ref);
317                 REFRESH_SPEEDUP(dsr_cntrl);
318                 break;
319         default:
320                 pr_err("%s: Failed to set dram over temp state %lu\n",
321                        __func__, state);
322                 BUG();
323         }
324
325         __raw_writel(ref, burst_reg_addr[EMC_REFRESH_INDEX]);
326         __raw_writel(pre_ref, burst_reg_addr[EMC_PRE_REFRESH_REQ_CNT_INDEX]);
327         __raw_writel(dsr_cntrl, burst_reg_addr[EMC_DYN_SELF_REF_CONTROL_INDEX]);
328 }
329
330 static inline void set_mc_arbiter_limits(void)
331 {
332         u32 reg = mc_readl(MC_EMEM_ARB_OUTSTANDING_REQ);
333         u32 max_val = 0x50 << EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT;
334
335         if (!(reg & MC_EMEM_ARB_OUTSTANDING_REQ_HOLDOFF_OVERRIDE) ||
336             ((reg & MC_EMEM_ARB_OUTSTANDING_REQ_MAX_MASK) > max_val)) {
337                 reg = MC_EMEM_ARB_OUTSTANDING_REQ_LIMIT_ENABLE |
338                         MC_EMEM_ARB_OUTSTANDING_REQ_HOLDOFF_OVERRIDE | max_val;
339                 mc_writel(reg, MC_EMEM_ARB_OUTSTANDING_REQ);
340                 mc_writel(0x1, MC_TIMING_CONTROL);
341         }
342 }
343
344 static inline void disable_early_ack(u32 mc_override)
345 {
346         static u32 override_val;
347
348         override_val = mc_override & (~MC_EMEM_ARB_OVERRIDE_EACK_MASK);
349         mc_writel(override_val, MC_EMEM_ARB_OVERRIDE);
350         __cpuc_flush_dcache_area(&override_val, sizeof(override_val));
351         outer_clean_range(__pa(&override_val), __pa(&override_val + 1));
352         override_val |= mc_override & MC_EMEM_ARB_OVERRIDE_EACK_MASK;
353 }
354
355 static inline void enable_early_ack(u32 mc_override)
356 {
357         mc_writel((mc_override | MC_EMEM_ARB_OVERRIDE_EACK_MASK),
358                         MC_EMEM_ARB_OVERRIDE);
359 }
360
361 static inline bool dqs_preset(const struct tegra_emc_table *next_timing,
362                               const struct tegra_emc_table *last_timing)
363 {
364         bool ret = false;
365
366 #define DQS_SET(reg, bit)                                                     \
367         do {                                                                  \
368                 if ((next_timing->burst_regs[EMC_##reg##_INDEX] &             \
369                      EMC_##reg##_##bit##_ENABLE) &&                           \
370                     (!(last_timing->burst_regs[EMC_##reg##_INDEX] &           \
371                        EMC_##reg##_##bit##_ENABLE)))   {                      \
372                         emc_writel(last_timing->burst_regs[EMC_##reg##_INDEX] \
373                                    | EMC_##reg##_##bit##_ENABLE, EMC_##reg);  \
374                         ret = true;                                           \
375                 }                                                             \
376         } while (0)
377
378         DQS_SET(XM2DQSPADCTRL2, VREF);
379         DQS_SET(XM2DQSPADCTRL3, VREF);
380         DQS_SET(XM2QUSEPADCTRL, IVREF);
381
382         return ret;
383 }
384
385 static inline void overwrite_mrs_wait_cnt(
386         const struct tegra_emc_table *next_timing,
387         bool zcal_long)
388 {
389         u32 reg;
390         u32 cnt = 512;
391
392         /* For ddr3 when DLL is re-started: overwrite EMC DFS table settings
393            for MRS_WAIT_LONG with maximum of MRS_WAIT_SHORT settings and
394            expected operation length. Reduce the latter by the overlapping
395            zq-calibration, if any */
396         if (zcal_long)
397                 cnt -= dram_dev_num * 256;
398
399         reg = (next_timing->burst_regs[EMC_MRS_WAIT_CNT_INDEX] &
400                 EMC_MRS_WAIT_CNT_SHORT_WAIT_MASK) >>
401                 EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT;
402         if (cnt < reg)
403                 cnt = reg;
404
405         reg = (next_timing->burst_regs[EMC_MRS_WAIT_CNT_INDEX] &
406                 (~EMC_MRS_WAIT_CNT_LONG_WAIT_MASK));
407         reg |= (cnt << EMC_MRS_WAIT_CNT_LONG_WAIT_SHIFT) &
408                 EMC_MRS_WAIT_CNT_LONG_WAIT_MASK;
409
410         emc_writel(reg, EMC_MRS_WAIT_CNT);
411 }
412
413 static inline bool need_qrst(const struct tegra_emc_table *next_timing,
414                              const struct tegra_emc_table *last_timing,
415                              u32 emc_dpd_reg)
416 {
417         u32 last_mode = (last_timing->burst_regs[EMC_FBIO_CFG5_INDEX] &
418                 EMC_CFG5_QUSE_MODE_MASK) >> EMC_CFG5_QUSE_MODE_SHIFT;
419         u32 next_mode = (next_timing->burst_regs[EMC_FBIO_CFG5_INDEX] &
420                 EMC_CFG5_QUSE_MODE_MASK) >> EMC_CFG5_QUSE_MODE_SHIFT;
421
422         /* QUSE DPD is disabled */
423         bool ret = !(emc_dpd_reg & EMC_SEL_DPD_CTRL_QUSE_DPD_ENABLE) &&
424
425         /* QUSE uses external mode before or after clock change */
426                 (((last_mode != EMC_CFG5_QUSE_MODE_PULSE_INTERN) &&
427                   (last_mode != EMC_CFG5_QUSE_MODE_INTERNAL_LPBK)) ||
428                  ((next_mode != EMC_CFG5_QUSE_MODE_PULSE_INTERN) &&
429                   (next_mode != EMC_CFG5_QUSE_MODE_INTERNAL_LPBK)))  &&
430
431         /* QUSE pad switches from schmitt to vref mode */
432                 (((last_timing->burst_regs[EMC_XM2QUSEPADCTRL_INDEX] &
433                    EMC_XM2QUSEPADCTRL_IVREF_ENABLE) == 0) &&
434                  ((next_timing->burst_regs[EMC_XM2QUSEPADCTRL_INDEX] &
435                    EMC_XM2QUSEPADCTRL_IVREF_ENABLE) != 0));
436
437         return ret;
438 }
439
440 static inline void periodic_qrst_enable(u32 emc_cfg_reg, u32 emc_dbg_reg)
441 {
442         /* enable write mux => enable periodic QRST => restore mux */
443         emc_writel(emc_dbg_reg | EMC_DBG_WRITE_MUX_ACTIVE, EMC_DBG);
444         emc_writel(emc_cfg_reg | EMC_CFG_PERIODIC_QRST, EMC_CFG);
445         emc_writel(emc_dbg_reg, EMC_DBG);
446 }
447
448 static inline int get_dll_change(const struct tegra_emc_table *next_timing,
449                                  const struct tegra_emc_table *last_timing)
450 {
451         bool next_dll_enabled = !(next_timing->emc_mode_1 & 0x1);
452         bool last_dll_enabled = !(last_timing->emc_mode_1 & 0x1);
453
454         if (next_dll_enabled == last_dll_enabled)
455                 return DLL_CHANGE_NONE;
456         else if (next_dll_enabled)
457                 return DLL_CHANGE_ON;
458         else
459                 return DLL_CHANGE_OFF;
460 }
461
462 static inline void set_dram_mode(const struct tegra_emc_table *next_timing,
463                                  const struct tegra_emc_table *last_timing,
464                                  int dll_change)
465 {
466         if (dram_type == DRAM_TYPE_DDR3) {
467                 /* first mode_1, then mode_2, then mode_reset*/
468                 if (next_timing->emc_mode_1 != last_timing->emc_mode_1)
469                         emc_writel(next_timing->emc_mode_1, EMC_EMRS);
470                 if (next_timing->emc_mode_2 != last_timing->emc_mode_2)
471                         emc_writel(next_timing->emc_mode_2, EMC_EMRS);
472
473                 if ((next_timing->emc_mode_reset !=
474                      last_timing->emc_mode_reset) ||
475                     (dll_change == DLL_CHANGE_ON))
476                 {
477                         u32 reg = next_timing->emc_mode_reset &
478                                 (~EMC_MODE_SET_DLL_RESET);
479                         if (dll_change == DLL_CHANGE_ON) {
480                                 reg |= EMC_MODE_SET_DLL_RESET;
481                                 reg |= EMC_MODE_SET_LONG_CNT;
482                         }
483                         emc_writel(reg, EMC_MRS);
484                 }
485         } else {
486                 /* first mode_2, then mode_1; mode_reset is not applicable */
487                 if (next_timing->emc_mode_2 != last_timing->emc_mode_2)
488                         emc_writel(next_timing->emc_mode_2, EMC_MRW);
489                 if (next_timing->emc_mode_1 != last_timing->emc_mode_1)
490                         emc_writel(next_timing->emc_mode_1, EMC_MRW);
491         }
492 }
493
494 static inline void do_clock_change(u32 clk_setting)
495 {
496         int err;
497
498         mc_readl(MC_EMEM_ADR_CFG);      /* completes prev writes */
499         writel(clk_setting, clk_base + emc->reg);
500
501         err = wait_for_update(EMC_INTSTATUS,
502                               EMC_INTSTATUS_CLKCHANGE_COMPLETE, true);
503         if (err) {
504                 pr_err("%s: clock change completion error: %d", __func__, err);
505                 BUG();
506         }
507 }
508
509 static noinline void emc_set_clock(const struct tegra_emc_table *next_timing,
510                                    const struct tegra_emc_table *last_timing,
511                                    u32 clk_setting)
512 {
513         int i, dll_change, pre_wait;
514         bool dyn_sref_enabled, vref_cal_toggle, qrst_used, zcal_long;
515
516         u32 mc_override = mc_readl(MC_EMEM_ARB_OVERRIDE);
517         u32 emc_cfg_reg = emc_readl(EMC_CFG);
518         u32 emc_dbg_reg = emc_readl(EMC_DBG);
519
520         dyn_sref_enabled = emc_cfg_reg & EMC_CFG_DYN_SREF_ENABLE;
521         dll_change = get_dll_change(next_timing, last_timing);
522         zcal_long = (next_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] != 0) &&
523                 (last_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] == 0);
524
525         /* FIXME: remove steps enumeration below? */
526
527         /* 1. clear clkchange_complete interrupts */
528         emc_writel(EMC_INTSTATUS_CLKCHANGE_COMPLETE, EMC_INTSTATUS);
529
530         /* 2. disable dynamic self-refresh and preset dqs vref, then wait for
531            possible self-refresh entry/exit and/or dqs vref settled - waiting
532            before the clock change decreases worst case change stall time */
533         pre_wait = 0;
534         if (dyn_sref_enabled) {
535                 emc_cfg_reg &= ~EMC_CFG_DYN_SREF_ENABLE;
536                 emc_writel(emc_cfg_reg, EMC_CFG);
537                 pre_wait = 5;           /* 5us+ for self-refresh entry/exit */
538         }
539
540         /* 2.25 update MC arbiter settings */
541         set_mc_arbiter_limits();
542         if (mc_override & MC_EMEM_ARB_OVERRIDE_EACK_MASK)
543                 disable_early_ack(mc_override);
544
545         /* 2.5 check dq/dqs vref delay */
546         if (dqs_preset(next_timing, last_timing)) {
547                 if (pre_wait < 3)
548                         pre_wait = 3;   /* 3us+ for dqs vref settled */
549         }
550         if (pre_wait) {
551                 emc_timing_update();
552                 udelay(pre_wait);
553         }
554
555         /* 3. disable auto-cal if vref mode is switching */
556         vref_cal_toggle = (next_timing->emc_acal_interval != 0) &&
557                 ((next_timing->burst_regs[EMC_XM2COMPPADCTRL_INDEX] ^
558                   last_timing->burst_regs[EMC_XM2COMPPADCTRL_INDEX]) &
559                  EMC_XM2COMPPADCTRL_VREF_CAL_ENABLE);
560         if (vref_cal_toggle)
561                 auto_cal_disable();
562
563         /* 4. program burst shadow registers */
564         for (i = 0; i < emc_num_burst_regs; i++) {
565                 if (!burst_reg_addr[i])
566                         continue;
567                 __raw_writel(next_timing->burst_regs[i], burst_reg_addr[i]);
568         }
569         if ((dram_type == DRAM_TYPE_LPDDR2) &&
570             (dram_over_temp_state != DRAM_OVER_TEMP_NONE))
571                 set_over_temp_timing(next_timing, dram_over_temp_state);
572         wmb();
573         barrier();
574
575         /* On ddr3 when DLL is re-started predict MRS long wait count and
576            overwrite DFS table setting */
577         if ((dram_type == DRAM_TYPE_DDR3) && (dll_change == DLL_CHANGE_ON))
578                 overwrite_mrs_wait_cnt(next_timing, zcal_long);
579
580         /* the last read below makes sure prev writes are completed */
581         qrst_used = need_qrst(next_timing, last_timing,
582                               emc_readl(EMC_SEL_DPD_CTRL));
583
584         /* 5. flow control marker 1 (no EMC read access after this) */
585         emc_writel(1, EMC_STALL_BEFORE_CLKCHANGE);
586
587         /* 6. enable periodic QRST */
588         if (qrst_used)
589                 periodic_qrst_enable(emc_cfg_reg, emc_dbg_reg);
590
591         /* 6.1 disable auto-refresh to save time after clock change */
592         emc_writel(EMC_REFCTRL_DISABLE_ALL(dram_dev_num), EMC_REFCTRL);
593
594         /* 7. turn Off dll and enter self-refresh on DDR3 */
595         if (dram_type == DRAM_TYPE_DDR3) {
596                 if (dll_change == DLL_CHANGE_OFF)
597                         emc_writel(next_timing->emc_mode_1, EMC_EMRS);
598                 emc_writel(DRAM_BROADCAST(dram_dev_num) |
599                            EMC_SELF_REF_CMD_ENABLED, EMC_SELF_REF);
600         }
601
602         /* 8. flow control marker 2 */
603         emc_writel(1, EMC_STALL_AFTER_CLKCHANGE);
604
605         /* 8.1 enable write mux, update unshadowed pad control */
606         emc_writel(emc_dbg_reg | EMC_DBG_WRITE_MUX_ACTIVE, EMC_DBG);
607         emc_writel(next_timing->burst_regs[EMC_XM2CLKPADCTRL_INDEX],
608                    EMC_XM2CLKPADCTRL);
609
610         /* 9. restore periodic QRST, and disable write mux */
611         if ((qrst_used) || (next_timing->emc_periodic_qrst !=
612                             last_timing->emc_periodic_qrst)) {
613                 emc_cfg_reg = next_timing->emc_periodic_qrst ?
614                         emc_cfg_reg | EMC_CFG_PERIODIC_QRST :
615                         emc_cfg_reg & (~EMC_CFG_PERIODIC_QRST);
616                 emc_writel(emc_cfg_reg, EMC_CFG);
617         }
618         emc_writel(emc_dbg_reg, EMC_DBG);
619
620         /* 10. exit self-refresh on DDR3 */
621         if (dram_type == DRAM_TYPE_DDR3)
622                 emc_writel(DRAM_BROADCAST(dram_dev_num), EMC_SELF_REF);
623
624         /* 11. set dram mode registers */
625         set_dram_mode(next_timing, last_timing, dll_change);
626
627         /* 12. issue zcal command if turning zcal On */
628         if (zcal_long) {
629                 emc_writel(EMC_ZQ_CAL_LONG_CMD_DEV0, EMC_ZQ_CAL);
630                 if (dram_dev_num > 1)
631                         emc_writel(EMC_ZQ_CAL_LONG_CMD_DEV1, EMC_ZQ_CAL);
632         }
633
634         /* 13. flow control marker 3 */
635         emc_writel(1, EMC_UNSTALL_RW_AFTER_CLKCHANGE);
636
637         /* 14. read any MC register to ensure the programming is done
638                change EMC clock source register (EMC read access restored)
639                wait for clk change completion */
640         do_clock_change(clk_setting);
641
642         /* 14.1 re-enable auto-refresh */
643         emc_writel(EMC_REFCTRL_ENABLE_ALL(dram_dev_num), EMC_REFCTRL);
644
645         /* 15. restore auto-cal */
646         if (vref_cal_toggle)
647                 emc_writel(next_timing->emc_acal_interval,
648                            EMC_AUTO_CAL_INTERVAL);
649
650         /* 16. restore dynamic self-refresh */
651         if (next_timing->rev >= 0x32)
652                 dyn_sref_enabled = next_timing->emc_dsr;
653         if (dyn_sref_enabled) {
654                 emc_cfg_reg |= EMC_CFG_DYN_SREF_ENABLE;
655                 emc_writel(emc_cfg_reg, EMC_CFG);
656         }
657
658         /* 17. set zcal wait count */
659         if (zcal_long)
660                 emc_writel(next_timing->emc_zcal_cnt_long, EMC_ZCAL_WAIT_CNT);
661
662         /* 18. update restored timing */
663         udelay(2);
664         emc_timing_update();
665
666         /* 18.a restore early ACK */
667         mc_writel(mc_override, MC_EMEM_ARB_OVERRIDE);
668 }
669
670 static inline void emc_get_timing(struct tegra_emc_table *timing)
671 {
672         int i;
673
674         for (i = 0; i < emc_num_burst_regs; i++) {
675                 if (burst_reg_addr[i])
676                         timing->burst_regs[i] = __raw_readl(burst_reg_addr[i]);
677                 else
678                         timing->burst_regs[i] = 0;
679         }
680         timing->emc_acal_interval = 0;
681         timing->emc_zcal_cnt_long = 0;
682         timing->emc_mode_reset = 0;
683         timing->emc_mode_1 = 0;
684         timing->emc_mode_2 = 0;
685         timing->emc_periodic_qrst = (emc_readl(EMC_CFG) &
686                                      EMC_CFG_PERIODIC_QRST) ? 1 : 0;
687 }
688
689 /* After deep sleep EMC power features are not restored.
690  * Do it at run-time after the 1st clock change.
691  */
692 static inline void emc_cfg_power_restore(void)
693 {
694         u32 reg = emc_readl(EMC_CFG);
695         u32 pwr_mask = EMC_CFG_PWR_MASK;
696
697         if (tegra_emc_table[0].rev >= 0x32)
698                 pwr_mask &= ~EMC_CFG_DYN_SREF_ENABLE;
699
700         if ((reg ^ emc_cfg_saved) & pwr_mask) {
701                 reg = (reg & (~pwr_mask)) | (emc_cfg_saved & pwr_mask);
702                 emc_writel(reg, EMC_CFG);
703                 emc_timing_update();
704         }
705 }
706
707 /* The EMC registers have shadow registers. When the EMC clock is updated
708  * in the clock controller, the shadow registers are copied to the active
709  * registers, allowing glitchless memory bus frequency changes.
710  * This function updates the shadow registers for a new clock frequency,
711  * and relies on the clock lock on the emc clock to avoid races between
712  * multiple frequency changes */
713 int tegra_emc_set_rate(unsigned long rate)
714 {
715         int i;
716         u32 clk_setting;
717         const struct tegra_emc_table *last_timing;
718         unsigned long flags;
719
720         if (!tegra_emc_table)
721                 return -EINVAL;
722
723         /* Table entries specify rate in kHz */
724         rate = rate / 1000;
725
726         for (i = 0; i < tegra_emc_table_size; i++) {
727                 if (tegra_emc_clk_sel[i].input == NULL)
728                         continue;       /* invalid entry */
729
730                 if (tegra_emc_table[i].rate == rate)
731                         break;
732         }
733
734         if (i >= tegra_emc_table_size)
735                 return -EINVAL;
736
737         if (!emc_timing) {
738                 /* can not assume that boot timing matches dfs table even
739                    if boot frequency matches one of the table nodes */
740                 emc_get_timing(&start_timing);
741                 last_timing = &start_timing;
742         }
743         else
744                 last_timing = emc_timing;
745
746         clk_setting = tegra_emc_clk_sel[i].value;
747
748         spin_lock_irqsave(&emc_access_lock, flags);
749         emc_set_clock(&tegra_emc_table[i], last_timing, clk_setting);
750         if (!emc_timing)
751                 emc_cfg_power_restore();
752         emc_timing = &tegra_emc_table[i];
753         spin_unlock_irqrestore(&emc_access_lock, flags);
754
755         emc_last_stats_update(i);
756
757         pr_debug("%s: rate %lu setting 0x%x\n", __func__, rate, clk_setting);
758
759         return 0;
760 }
761
762 /* Select the closest EMC rate that is higher than the requested rate */
763 long tegra_emc_round_rate(unsigned long rate)
764 {
765         int i;
766         int best = -1;
767         unsigned long distance = ULONG_MAX;
768
769         if (!tegra_emc_table)
770                 return clk_get_rate_locked(emc); /* no table - no rate change */
771
772         if (!emc_enable)
773                 return -EINVAL;
774
775         pr_debug("%s: %lu\n", __func__, rate);
776
777         /* Table entries specify rate in kHz */
778         rate = rate / 1000;
779
780         for (i = 0; i < tegra_emc_table_size; i++) {
781                 if (tegra_emc_clk_sel[i].input == NULL)
782                         continue;       /* invalid entry */
783
784                 if (tegra_emc_table[i].rate >= rate &&
785                     (tegra_emc_table[i].rate - rate) < distance) {
786                         distance = tegra_emc_table[i].rate - rate;
787                         best = i;
788                 }
789         }
790
791         if (best < 0)
792                 return -EINVAL;
793
794         pr_debug("%s: using %lu\n", __func__, tegra_emc_table[best].rate);
795
796         return tegra_emc_table[best].rate * 1000;
797 }
798
799 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
800 {
801         int i;
802
803         if (!tegra_emc_table)
804                 return NULL;
805
806         pr_debug("%s: %lu\n", __func__, rate);
807
808         /* Table entries specify rate in kHz */
809         rate = rate / 1000;
810
811         for (i = 0; i < tegra_emc_table_size; i++) {
812                 if (tegra_emc_table[i].rate == rate) {
813                         *div_value = (tegra_emc_clk_sel[i].value &
814                                 EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
815                         return tegra_emc_clk_sel[i].input;
816                 }
817         }
818
819         return NULL;
820 }
821
822 static const struct clk_mux_sel *find_matching_input(
823         unsigned long table_rate,
824         u32 *div_value)
825 {
826         unsigned long inp_rate;
827         const struct clk_mux_sel *sel;
828
829         for (sel = emc->inputs; sel->input != NULL; sel++) {
830                 /* Table entries specify rate in kHz */
831                 inp_rate = clk_get_rate(sel->input) / 1000;
832
833                 if ((inp_rate >= table_rate) &&
834                      (inp_rate % table_rate == 0)) {
835                         *div_value = 2 * inp_rate / table_rate - 2;
836                         return sel;
837                 }
838         }
839         return NULL;
840 }
841
842 static void adjust_emc_dvfs_table(const struct tegra_emc_table *table,
843                                   int table_size)
844 {
845         int i, j;
846         unsigned long rate;
847
848         if (table[0].rev < 0x33)
849                 return;
850
851         for (i = 0; i < MAX_DVFS_FREQS; i++) {
852                 int mv = emc->dvfs->millivolts[i];
853                 if (!mv)
854                         break;
855
856                 /* For each dvfs voltage find maximum supported rate;
857                    use 1MHz placeholder if not found */
858                 for (rate = 1000, j = 0; j < table_size; j++) {
859                         if (tegra_emc_clk_sel[j].input == NULL)
860                                 continue;       /* invalid entry */
861
862                         if ((mv >= table[j].emc_min_mv) &&
863                             (rate < table[j].rate))
864                                 rate = table[j].rate;
865                 }
866                 /* Table entries specify rate in kHz */
867                 emc->dvfs->freqs[i] = rate * 1000;
868         }
869 }
870
871 static bool is_emc_bridge(void)
872 {
873         int mv;
874         unsigned long rate;
875
876         bridge = tegra_get_clock_by_name("bridge.emc");
877         BUG_ON(!bridge);
878
879         /* LPDDR2 does not need a bridge entry in DFS table: just lock bridge
880            rate at minimum so it won't interfere with emc bus operations */
881         if (dram_type == DRAM_TYPE_LPDDR2) {
882                 clk_set_rate(bridge, 0);
883                 return true;
884         }
885
886         /* DDR3 requires EMC DFS table to include a bridge entry with frequency
887            above minimum bridge threshold, and voltage below bridge threshold */
888         rate = clk_round_rate(bridge, TEGRA_EMC_BRIDGE_RATE_MIN);
889         if (IS_ERR_VALUE(rate))
890                 return false;
891
892         mv = tegra_dvfs_predict_millivolts(emc, rate);
893         if (IS_ERR_VALUE(mv) || (mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN))
894                 return false;
895
896         if (clk_set_rate(bridge, rate))
897                 return false;
898
899         return true;
900 }
901
902 static int tegra_emc_suspend_notify(struct notifier_block *nb,
903                                 unsigned long event, void *data)
904 {
905         if (event != PM_SUSPEND_PREPARE)
906                 return NOTIFY_OK;
907
908         if (dram_type == DRAM_TYPE_DDR3) {
909                 if (clk_enable(bridge)) {
910                         pr_info("Tegra emc suspend:"
911                                 " failed to enable bridge.emc\n");
912                         return NOTIFY_STOP;
913                 }
914                 pr_info("Tegra emc suspend: enabled bridge.emc\n");
915         }
916         return NOTIFY_OK;
917 };
918 static struct notifier_block tegra_emc_suspend_nb = {
919         .notifier_call = tegra_emc_suspend_notify,
920         .priority = 2,
921 };
922
923 static int tegra_emc_resume_notify(struct notifier_block *nb,
924                                 unsigned long event, void *data)
925 {
926         if (event != PM_POST_SUSPEND)
927                 return NOTIFY_OK;
928
929         if (dram_type == DRAM_TYPE_DDR3) {
930                 clk_disable(bridge);
931                 pr_info("Tegra emc resume: disabled bridge.emc\n");
932         }
933         return NOTIFY_OK;
934 };
935 static struct notifier_block tegra_emc_resume_nb = {
936         .notifier_call = tegra_emc_resume_notify,
937         .priority = -1,
938 };
939
940 void tegra_init_emc(const struct tegra_emc_table *table, int table_size)
941 {
942         int i, mv;
943         u32 reg, div_value;
944         bool max_entry = false;
945         unsigned long boot_rate, max_rate;
946         const struct clk_mux_sel *sel;
947
948         emc_stats.clkchange_count = 0;
949         spin_lock_init(&emc_stats.spinlock);
950         emc_stats.last_update = get_jiffies_64();
951         emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
952
953         boot_rate = clk_get_rate(emc) / 1000;
954         max_rate = clk_get_max_rate(emc) / 1000;
955
956         if ((dram_type != DRAM_TYPE_DDR3) && (dram_type != DRAM_TYPE_LPDDR2)) {
957                 pr_err("tegra: not supported DRAM type %u\n", dram_type);
958                 return;
959         }
960
961         if (emc->parent != tegra_get_clock_by_name("pll_m")) {
962                 pr_err("tegra: boot parent %s is not supported by EMC DFS\n",
963                         emc->parent->name);
964                 return;
965         }
966
967         if (!table || !table_size) {
968                 pr_err("tegra: EMC DFS table is empty\n");
969                 return;
970         }
971
972         tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
973         switch (table[0].rev) {
974         case 0x30:
975                 emc_num_burst_regs = 105;
976                 break;
977         case 0x31:
978         case 0x32:
979         case 0x33:
980                 emc_num_burst_regs = 107;
981                 break;
982         default:
983                 pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
984                         table[0].rev);
985                 return;
986         }
987
988         /* Match EMC source/divider settings with table entries */
989         for (i = 0; i < tegra_emc_table_size; i++) {
990                 unsigned long table_rate = table[i].rate;
991                 if (!table_rate)
992                         continue;
993
994                 BUG_ON(table[i].rev != table[0].rev);
995
996                 sel = find_matching_input(table_rate, &div_value);
997                 if (!sel)
998                         continue;
999
1000                 if (table_rate == boot_rate)
1001                         emc_stats.last_sel = i;
1002
1003                 if (table_rate == max_rate)
1004                         max_entry = true;
1005
1006                 tegra_emc_clk_sel[i] = *sel;
1007                 BUG_ON(div_value >
1008                        (EMC_CLK_DIV_MASK >> EMC_CLK_DIV_SHIFT));
1009                 tegra_emc_clk_sel[i].value <<= EMC_CLK_SOURCE_SHIFT;
1010                 tegra_emc_clk_sel[i].value |= (div_value << EMC_CLK_DIV_SHIFT);
1011
1012                 if ((div_value == 0) &&
1013                     (tegra_emc_clk_sel[i].input == emc->parent)) {
1014                         tegra_emc_clk_sel[i].value |= EMC_CLK_LOW_JITTER_ENABLE;
1015                 }
1016
1017                 if (table[i].burst_regs[MC_EMEM_ARB_MISC0_INDEX] &
1018                     MC_EMEM_ARB_MISC0_EMC_SAME_FREQ)
1019                         tegra_emc_clk_sel[i].value |= EMC_CLK_MC_SAME_FREQ;
1020         }
1021
1022         /* Validate EMC rate and voltage limits */
1023         if (!max_entry) {
1024                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
1025                        " %lu kHz is not found\n", max_rate);
1026                 return;
1027         }
1028
1029         tegra_emc_table = table;
1030
1031         adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
1032         mv = tegra_dvfs_predict_millivolts(emc, max_rate * 1000);
1033         if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
1034                 tegra_emc_table = NULL;
1035                 pr_err("tegra: invalid EMC DFS table: maximum rate %lu kHz does"
1036                        " not match nominal voltage %d\n",
1037                        max_rate, emc->dvfs->max_millivolts);
1038                 return;
1039         }
1040
1041         if (!is_emc_bridge()) {
1042                 tegra_emc_table = NULL;
1043                 pr_err("tegra: invalid EMC DFS table: emc bridge not found");
1044                 return;
1045         }
1046         pr_info("tegra: validated EMC DFS table\n");
1047
1048         /* Configure clock change mode according to dram type */
1049         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
1050         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
1051                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
1052         emc_writel(reg, EMC_CFG_2);
1053
1054         register_pm_notifier(&tegra_emc_suspend_nb);
1055         register_pm_notifier(&tegra_emc_resume_nb);
1056 }
1057
1058 void tegra_emc_timing_invalidate(void)
1059 {
1060         emc_timing = NULL;
1061 }
1062
1063 void tegra_init_dram_bit_map(const u32 *bit_map, int map_size)
1064 {
1065         BUG_ON(map_size != 32);
1066         dram_to_soc_bit_map = bit_map;
1067 }
1068
1069 void tegra_emc_dram_type_init(struct clk *c)
1070 {
1071         emc = c;
1072
1073         dram_type = (emc_readl(EMC_FBIO_CFG5) &
1074                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
1075         if (dram_type == DRAM_TYPE_DDR3)
1076                 emc->min_rate = EMC_MIN_RATE_DDR3;
1077
1078         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
1079         emc_cfg_saved = emc_readl(EMC_CFG);
1080 }
1081
1082 int tegra_emc_get_dram_type(void)
1083 {
1084         return dram_type;
1085 }
1086
1087 static u32 soc_to_dram_bit_swap(u32 soc_val, u32 dram_mask, u32 dram_shift)
1088 {
1089         int bit;
1090         u32 dram_val = 0;
1091
1092         /* tegra clocks definitions use shifted mask always */
1093         if (!dram_to_soc_bit_map)
1094                 return soc_val & dram_mask;
1095
1096         for (bit = dram_shift; bit < 32; bit++) {
1097                 u32 dram_bit_mask = 0x1 << bit;
1098                 u32 soc_bit_mask = dram_to_soc_bit_map[bit];
1099
1100                 if (!(dram_bit_mask & dram_mask))
1101                         break;
1102
1103                 if (soc_bit_mask & soc_val)
1104                         dram_val |= dram_bit_mask;
1105         }
1106
1107         return dram_val;
1108 }
1109
1110 static int emc_read_mrr(int dev, int addr)
1111 {
1112         int ret;
1113         u32 val;
1114
1115         if (dram_type != DRAM_TYPE_LPDDR2)
1116                 return -ENODEV;
1117
1118         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, false);
1119         if (ret)
1120                 return ret;
1121
1122         val = dev ? DRAM_DEV_SEL_1 : DRAM_DEV_SEL_0;
1123         val |= (addr << EMC_MRR_MA_SHIFT) & EMC_MRR_MA_MASK;
1124         emc_writel(val, EMC_MRR);
1125
1126         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, true);
1127         if (ret)
1128                 return ret;
1129
1130         val = emc_readl(EMC_MRR) & EMC_MRR_DATA_MASK;
1131         return val;
1132 }
1133
1134 int tegra_emc_get_dram_temperature(void)
1135 {
1136         int mr4;
1137         unsigned long flags;
1138
1139         spin_lock_irqsave(&emc_access_lock, flags);
1140
1141         mr4 = emc_read_mrr(0, 4);
1142         if (IS_ERR_VALUE(mr4)) {
1143                 spin_unlock_irqrestore(&emc_access_lock, flags);
1144                 return mr4;
1145         }
1146         spin_unlock_irqrestore(&emc_access_lock, flags);
1147
1148         mr4 = soc_to_dram_bit_swap(
1149                 mr4, LPDDR2_MR4_TEMP_MASK, LPDDR2_MR4_TEMP_SHIFT);
1150         return mr4;
1151 }
1152
1153 int tegra_emc_set_over_temp_state(unsigned long state)
1154 {
1155         unsigned long flags;
1156
1157         if (dram_type != DRAM_TYPE_LPDDR2)
1158                 return -ENODEV;
1159
1160         spin_lock_irqsave(&emc_access_lock, flags);
1161
1162         /* Update refresh timing if state changed */
1163         if (emc_timing && (dram_over_temp_state != state)) {
1164                 set_over_temp_timing(emc_timing, state);
1165                 emc_timing_update();
1166                 if (state != DRAM_OVER_TEMP_NONE)
1167                         emc_writel(EMC_REF_FORCE_CMD, EMC_REF);
1168                 dram_over_temp_state = state;
1169         }
1170         spin_unlock_irqrestore(&emc_access_lock, flags);
1171         return 0;
1172 }
1173
1174 int tegra_emc_set_eack_state(unsigned long state)
1175 {
1176         unsigned long flags;
1177         u32 mc_override;
1178
1179         spin_lock_irqsave(&emc_access_lock, flags);
1180
1181         mc_override = mc_readl(MC_EMEM_ARB_OVERRIDE);
1182
1183         if (state)
1184                 enable_early_ack(mc_override);
1185         else
1186                 disable_early_ack(mc_override);
1187
1188         spin_unlock_irqrestore(&emc_access_lock, flags);
1189         return 0;
1190 }
1191
1192 #ifdef CONFIG_DEBUG_FS
1193
1194 static struct dentry *emc_debugfs_root;
1195
1196 static int emc_stats_show(struct seq_file *s, void *data)
1197 {
1198         int i;
1199
1200         emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE);
1201
1202         seq_printf(s, "%-10s %-10s \n", "rate kHz", "time");
1203         for (i = 0; i < tegra_emc_table_size; i++) {
1204                 if (tegra_emc_clk_sel[i].input == NULL)
1205                         continue;       /* invalid entry */
1206
1207                 seq_printf(s, "%-10lu %-10llu \n", tegra_emc_table[i].rate,
1208                            cputime64_to_clock_t(emc_stats.time_at_clock[i]));
1209         }
1210         seq_printf(s, "%-15s %llu\n", "transitions:",
1211                    emc_stats.clkchange_count);
1212         seq_printf(s, "%-15s %llu\n", "time-stamp:",
1213                    cputime64_to_clock_t(emc_stats.last_update));
1214
1215         return 0;
1216 }
1217
1218 static int emc_stats_open(struct inode *inode, struct file *file)
1219 {
1220         return single_open(file, emc_stats_show, inode->i_private);
1221 }
1222
1223 static const struct file_operations emc_stats_fops = {
1224         .open           = emc_stats_open,
1225         .read           = seq_read,
1226         .llseek         = seq_lseek,
1227         .release        = single_release,
1228 };
1229
1230 static int dram_temperature_get(void *data, u64 *val)
1231 {
1232         *val = tegra_emc_get_dram_temperature();
1233         return 0;
1234 }
1235 DEFINE_SIMPLE_ATTRIBUTE(dram_temperature_fops, dram_temperature_get,
1236                         NULL, "%lld\n");
1237
1238 static int over_temp_state_get(void *data, u64 *val)
1239 {
1240         *val = dram_over_temp_state;
1241         return 0;
1242 }
1243 static int over_temp_state_set(void *data, u64 val)
1244 {
1245         tegra_emc_set_over_temp_state(val);
1246         return 0;
1247 }
1248 DEFINE_SIMPLE_ATTRIBUTE(over_temp_state_fops, over_temp_state_get,
1249                         over_temp_state_set, "%llu\n");
1250
1251 static int eack_state_get(void *data, u64 *val)
1252 {
1253         unsigned long flags;
1254         u32 mc_override;
1255
1256         spin_lock_irqsave(&emc_access_lock, flags);
1257         mc_override = mc_readl(MC_EMEM_ARB_OVERRIDE);
1258         spin_unlock_irqrestore(&emc_access_lock, flags);
1259
1260         *val = (mc_override & MC_EMEM_ARB_OVERRIDE_EACK_MASK);
1261         return 0;
1262 }
1263
1264 static int eack_state_set(void *data, u64 val)
1265 {
1266         tegra_emc_set_eack_state(val);
1267         return 0;
1268 }
1269 DEFINE_SIMPLE_ATTRIBUTE(eack_state_fops, eack_state_get,
1270                         eack_state_set, "%llu\n");
1271
1272 static int efficiency_get(void *data, u64 *val)
1273 {
1274         *val = tegra_emc_bw_efficiency;
1275         return 0;
1276 }
1277 static int efficiency_set(void *data, u64 val)
1278 {
1279         tegra_emc_bw_efficiency = (val > 100) ? 100 : val;
1280         if (emc)
1281                 tegra_clk_shared_bus_update(emc);
1282
1283         return 0;
1284 }
1285 DEFINE_SIMPLE_ATTRIBUTE(efficiency_fops, efficiency_get,
1286                         efficiency_set, "%llu\n");
1287
1288 static int __init tegra_emc_debug_init(void)
1289 {
1290         if (!tegra_emc_table)
1291                 return 0;
1292
1293         emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL);
1294         if (!emc_debugfs_root)
1295                 return -ENOMEM;
1296
1297         if (!debugfs_create_file(
1298                 "stats", S_IRUGO, emc_debugfs_root, NULL, &emc_stats_fops))
1299                 goto err_out;
1300
1301         if (!debugfs_create_file("dram_temperature", S_IRUGO, emc_debugfs_root,
1302                                  NULL, &dram_temperature_fops))
1303                 goto err_out;
1304
1305         if (!debugfs_create_file("over_temp_state", S_IRUGO | S_IWUSR,
1306                                  emc_debugfs_root, NULL, &over_temp_state_fops))
1307                 goto err_out;
1308
1309         if (!debugfs_create_file(
1310                 "eack_state", S_IRUGO | S_IWUGO, emc_debugfs_root, NULL, &eack_state_fops))
1311                 goto err_out;
1312
1313         if (!debugfs_create_file("efficiency", S_IRUGO | S_IWUSR,
1314                                  emc_debugfs_root, NULL, &efficiency_fops))
1315                 goto err_out;
1316
1317         return 0;
1318
1319 err_out:
1320         debugfs_remove_recursive(emc_debugfs_root);
1321         return -ENOMEM;
1322 }
1323
1324 late_initcall(tegra_emc_debug_init);
1325 #endif