ARM: tegra: emc: Derating support
[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-2013, NVIDIA CORPORATION. All rights reserved.
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 #include <linux/of.h>
32 #include <linux/platform_device.h>
33 #include <linux/platform_data/tegra_emc.h>
34
35 #include <asm/cputime.h>
36 #include <asm/cacheflush.h>
37
38 #include <mach/latency_allowance.h>
39
40 #include "clock.h"
41 #include "dvfs.h"
42 #include "tegra3_emc.h"
43 #include "fuse.h"
44 #include "iomap.h"
45
46 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
47 static bool emc_enable = true;
48 #else
49 static bool emc_enable;
50 #endif
51 module_param(emc_enable, bool, 0644);
52
53 u8 tegra_emc_bw_efficiency = 35;
54 u8 tegra_emc_bw_efficiency_boost = 45;
55
56 #define EMC_MIN_RATE_DDR3               25500000
57 #define EMC_STATUS_UPDATE_TIMEOUT       100
58 #define TEGRA_EMC_TABLE_MAX_SIZE        16
59
60 enum {
61         DLL_CHANGE_NONE = 0,
62         DLL_CHANGE_ON,
63         DLL_CHANGE_OFF,
64 };
65
66 #define EMC_CLK_DIV_SHIFT               0
67 #define EMC_CLK_DIV_MASK                (0xFF << EMC_CLK_DIV_SHIFT)
68 #define EMC_CLK_SOURCE_SHIFT            30
69 #define EMC_CLK_SOURCE_MASK             (0x3 << EMC_CLK_SOURCE_SHIFT)
70 #define EMC_CLK_LOW_JITTER_ENABLE       (0x1 << 29)
71 #define EMC_CLK_MC_SAME_FREQ            (0x1 << 16)
72
73 #define BURST_REG_LIST \
74         DEFINE_REG(TEGRA_EMC_BASE, EMC_RC),                     \
75         DEFINE_REG(TEGRA_EMC_BASE, EMC_RFC),                    \
76         DEFINE_REG(TEGRA_EMC_BASE, EMC_RAS),                    \
77         DEFINE_REG(TEGRA_EMC_BASE, EMC_RP),                     \
78         DEFINE_REG(TEGRA_EMC_BASE, EMC_R2W),                    \
79         DEFINE_REG(TEGRA_EMC_BASE, EMC_W2R),                    \
80         DEFINE_REG(TEGRA_EMC_BASE, EMC_R2P),                    \
81         DEFINE_REG(TEGRA_EMC_BASE, EMC_W2P),                    \
82         DEFINE_REG(TEGRA_EMC_BASE, EMC_RD_RCD),                 \
83         DEFINE_REG(TEGRA_EMC_BASE, EMC_WR_RCD),                 \
84         DEFINE_REG(TEGRA_EMC_BASE, EMC_RRD),                    \
85         DEFINE_REG(TEGRA_EMC_BASE, EMC_REXT),                   \
86         DEFINE_REG(TEGRA_EMC_BASE, EMC_WEXT),                   \
87         DEFINE_REG(TEGRA_EMC_BASE, EMC_WDV),                    \
88         DEFINE_REG(TEGRA_EMC_BASE, EMC_QUSE),                   \
89         DEFINE_REG(TEGRA_EMC_BASE, EMC_QRST),                   \
90         DEFINE_REG(TEGRA_EMC_BASE, EMC_QSAFE),                  \
91         DEFINE_REG(TEGRA_EMC_BASE, EMC_RDV),                    \
92         DEFINE_REG(TEGRA_EMC_BASE, EMC_REFRESH),                \
93         DEFINE_REG(TEGRA_EMC_BASE, EMC_BURST_REFRESH_NUM),      \
94         DEFINE_REG(TEGRA_EMC_BASE, EMC_PRE_REFRESH_REQ_CNT),    \
95         DEFINE_REG(TEGRA_EMC_BASE, EMC_PDEX2WR),                \
96         DEFINE_REG(TEGRA_EMC_BASE, EMC_PDEX2RD),                \
97         DEFINE_REG(TEGRA_EMC_BASE, EMC_PCHG2PDEN),              \
98         DEFINE_REG(TEGRA_EMC_BASE, EMC_ACT2PDEN),               \
99         DEFINE_REG(TEGRA_EMC_BASE, EMC_AR2PDEN),                \
100         DEFINE_REG(TEGRA_EMC_BASE, EMC_RW2PDEN),                \
101         DEFINE_REG(TEGRA_EMC_BASE, EMC_TXSR),                   \
102         DEFINE_REG(TEGRA_EMC_BASE, EMC_TXSRDLL),                \
103         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCKE),                   \
104         DEFINE_REG(TEGRA_EMC_BASE, EMC_TFAW),                   \
105         DEFINE_REG(TEGRA_EMC_BASE, EMC_TRPAB),                  \
106         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCLKSTABLE),             \
107         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCLKSTOP),               \
108         DEFINE_REG(TEGRA_EMC_BASE, EMC_TREFBW),                 \
109         DEFINE_REG(TEGRA_EMC_BASE, EMC_QUSE_EXTRA),             \
110         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_CFG6),              \
111         DEFINE_REG(TEGRA_EMC_BASE, EMC_ODT_WRITE),              \
112         DEFINE_REG(TEGRA_EMC_BASE, EMC_ODT_READ),               \
113         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_CFG5),              \
114         DEFINE_REG(TEGRA_EMC_BASE, EMC_CFG_DIG_DLL),            \
115         DEFINE_REG(TEGRA_EMC_BASE, EMC_CFG_DIG_DLL_PERIOD),     \
116         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS0),         \
117         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS1),         \
118         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS2),         \
119         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS3),         \
120         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS4),         \
121         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS5),         \
122         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS6),         \
123         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS7),         \
124         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE0),        \
125         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE1),        \
126         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE2),        \
127         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE3),        \
128         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE4),        \
129         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE5),        \
130         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE6),        \
131         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE7),        \
132         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS0),        \
133         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS1),        \
134         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS2),        \
135         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS3),        \
136         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS4),        \
137         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS5),        \
138         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS6),        \
139         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS7),        \
140         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ0),          \
141         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ1),          \
142         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ2),          \
143         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ3),          \
144         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2CMDPADCTRL),          \
145         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQSPADCTRL2),         \
146         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQPADCTRL2),          \
147         DEFINE_REG(0             , EMC_XM2CLKPADCTRL),          \
148         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2COMPPADCTRL),         \
149         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2VTTGENPADCTRL),       \
150         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2VTTGENPADCTRL2),      \
151         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2QUSEPADCTRL),         \
152         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQSPADCTRL3),         \
153         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT_TERM_CTRL),          \
154         DEFINE_REG(TEGRA_EMC_BASE, EMC_ZCAL_INTERVAL),          \
155         DEFINE_REG(TEGRA_EMC_BASE, EMC_ZCAL_WAIT_CNT),          \
156         DEFINE_REG(TEGRA_EMC_BASE, EMC_MRS_WAIT_CNT),           \
157         DEFINE_REG(TEGRA_EMC_BASE, EMC_AUTO_CAL_CONFIG),        \
158         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT),                    \
159         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT_DURATION),           \
160         DEFINE_REG(TEGRA_EMC_BASE, EMC_DYN_SELF_REF_CONTROL),   \
161                                                                 \
162         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_CFG),             \
163         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_OUTSTANDING_REQ), \
164         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RCD),      \
165         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RP),       \
166         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RC),       \
167         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RAS),      \
168         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_FAW),      \
169         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RRD),      \
170         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RAP2PRE),  \
171         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_WAP2PRE),  \
172         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_R2R),      \
173         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_W2W),      \
174         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_R2W),      \
175         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_W2R),      \
176         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_DA_TURNS),        \
177         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_DA_COVERS),       \
178         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_MISC0),           \
179         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_RING1_THROTTLE),  \
180                                                                 \
181         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_SPARE),             \
182         DEFINE_REG(TEGRA_EMC_BASE, EMC_CFG_RSV),
183
184 #define DEFINE_REG(base, reg) ((base) ? (IO_ADDRESS((base)) + (reg)) : 0)
185 static void __iomem *burst_reg_addr[TEGRA30_EMC_NUM_REGS] = {
186         BURST_REG_LIST
187 };
188 #undef DEFINE_REG
189
190 #define DEFINE_REG(base, reg)   reg##_INDEX
191 enum {
192         BURST_REG_LIST
193 };
194 #undef DEFINE_REG
195
196 static int emc_num_burst_regs;
197
198 struct emc_sel {
199         struct clk      *input;
200         u32             value;
201         unsigned long   input_rate;
202 };
203
204 static struct emc_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
205 static struct tegra30_emc_table start_timing;
206 static const struct tegra30_emc_table *emc_timing;
207 static unsigned long dram_over_temp_state = DRAM_OVER_TEMP_NONE;
208
209 static const u32 *dram_to_soc_bit_map;
210 static const struct tegra30_emc_table *tegra_emc_table;
211 static int tegra_emc_table_size;
212
213 static u32 dram_dev_num;
214 static u32 emc_cfg_saved;
215 static u32 dram_type = -1;
216
217 static struct clk *emc;
218 static struct clk *bridge;
219
220 static struct {
221         cputime64_t time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE];
222         int last_sel;
223         u64 last_update;
224         u64 clkchange_count;
225         spinlock_t spinlock;
226 } emc_stats;
227
228 static DEFINE_SPINLOCK(emc_access_lock);
229
230 static void __iomem *emc_base = IO_ADDRESS(TEGRA_EMC_BASE);
231 static void __iomem *mc_base = IO_ADDRESS(TEGRA_MC_BASE);
232 static void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
233
234 static inline void emc_writel(u32 val, unsigned long addr)
235 {
236         writel(val, emc_base + addr);
237         barrier();
238 }
239 static inline u32 emc_readl(unsigned long addr)
240 {
241         return readl(emc_base + addr);
242 }
243 static inline void mc_writel(u32 val, unsigned long addr)
244 {
245         writel(val, mc_base + addr);
246         barrier();
247 }
248 static inline u32 mc_readl(unsigned long addr)
249 {
250         return readl(mc_base + addr);
251 }
252
253 static void emc_last_stats_update(int last_sel)
254 {
255         unsigned long flags;
256         u64 cur_jiffies = get_jiffies_64();
257
258         spin_lock_irqsave(&emc_stats.spinlock, flags);
259
260         if (emc_stats.last_sel < TEGRA_EMC_TABLE_MAX_SIZE)
261                 emc_stats.time_at_clock[emc_stats.last_sel] =
262                         emc_stats.time_at_clock[emc_stats.last_sel] +
263                         (cur_jiffies - emc_stats.last_update);
264
265         emc_stats.last_update = cur_jiffies;
266
267         if (last_sel < TEGRA_EMC_TABLE_MAX_SIZE) {
268                 emc_stats.clkchange_count++;
269                 emc_stats.last_sel = last_sel;
270         }
271         spin_unlock_irqrestore(&emc_stats.spinlock, flags);
272 }
273
274 static int wait_for_update(u32 status_reg, u32 bit_mask, bool updated_state)
275 {
276         int i;
277         for (i = 0; i < EMC_STATUS_UPDATE_TIMEOUT; i++) {
278                 if (!!(emc_readl(status_reg) & bit_mask) == updated_state)
279                         return 0;
280                 udelay(1);
281         }
282         return -ETIMEDOUT;
283 }
284
285 static inline void emc_timing_update(void)
286 {
287         int err;
288
289         emc_writel(0x1, EMC_TIMING_CONTROL);
290         err = wait_for_update(EMC_STATUS,
291                               EMC_STATUS_TIMING_UPDATE_STALLED, false);
292         if (err) {
293                 pr_err("%s: timing update error: %d", __func__, err);
294                 BUG();
295         }
296 }
297
298 static inline void auto_cal_disable(void)
299 {
300         int err;
301
302         emc_writel(0, EMC_AUTO_CAL_INTERVAL);
303         err = wait_for_update(EMC_AUTO_CAL_STATUS,
304                               EMC_AUTO_CAL_STATUS_ACTIVE, false);
305         if (err) {
306                 pr_err("%s: disable auto-cal error: %d", __func__, err);
307                 BUG();
308         }
309 }
310
311 static inline void set_over_temp_timing(
312         const struct tegra30_emc_table *next_timing, unsigned long state)
313 {
314 #define REFRESH_SPEEDUP(val)                                                  \
315         do {                                                                  \
316                 val = ((val) & 0xFFFF0000) | (((val) & 0xFFFF) >> 2);         \
317         } while (0)
318
319         u32 ref = next_timing->burst_regs[EMC_REFRESH_INDEX];
320         u32 pre_ref = next_timing->burst_regs[EMC_PRE_REFRESH_REQ_CNT_INDEX];
321         u32 dsr_cntrl = next_timing->burst_regs[EMC_DYN_SELF_REF_CONTROL_INDEX];
322
323         switch (state) {
324         case DRAM_OVER_TEMP_NONE:
325                 break;
326         case DRAM_OVER_TEMP_REFRESH_X2:
327         case DRAM_OVER_TEMP_REFRESH_X4:
328         case DRAM_OVER_TEMP_THROTTLE:
329                 REFRESH_SPEEDUP(ref);
330                 REFRESH_SPEEDUP(pre_ref);
331                 REFRESH_SPEEDUP(dsr_cntrl);
332                 break;
333         default:
334                 pr_err("%s: Failed to set dram over temp state %lu\n",
335                        __func__, state);
336                 BUG();
337         }
338
339         __raw_writel(ref, burst_reg_addr[EMC_REFRESH_INDEX]);
340         __raw_writel(pre_ref, burst_reg_addr[EMC_PRE_REFRESH_REQ_CNT_INDEX]);
341         __raw_writel(dsr_cntrl, burst_reg_addr[EMC_DYN_SELF_REF_CONTROL_INDEX]);
342 }
343
344 static inline void set_mc_arbiter_limits(void)
345 {
346         u32 reg = mc_readl(MC_EMEM_ARB_OUTSTANDING_REQ);
347         u32 max_val = 0x50 << EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT;
348
349         if (!(reg & MC_EMEM_ARB_OUTSTANDING_REQ_HOLDOFF_OVERRIDE) ||
350             ((reg & MC_EMEM_ARB_OUTSTANDING_REQ_MAX_MASK) > max_val)) {
351                 reg = MC_EMEM_ARB_OUTSTANDING_REQ_LIMIT_ENABLE |
352                         MC_EMEM_ARB_OUTSTANDING_REQ_HOLDOFF_OVERRIDE | max_val;
353                 mc_writel(reg, MC_EMEM_ARB_OUTSTANDING_REQ);
354                 mc_writel(0x1, MC_TIMING_CONTROL);
355         }
356 }
357
358 static inline void disable_early_ack(u32 mc_override)
359 {
360         static u32 override_val;
361
362         override_val = mc_override & (~MC_EMEM_ARB_OVERRIDE_EACK_MASK);
363         mc_writel(override_val, MC_EMEM_ARB_OVERRIDE);
364         __cpuc_flush_dcache_area(&override_val, sizeof(override_val));
365         outer_clean_range(__pa(&override_val), __pa(&override_val + 1));
366         override_val |= mc_override & MC_EMEM_ARB_OVERRIDE_EACK_MASK;
367 }
368
369 static inline void enable_early_ack(u32 mc_override)
370 {
371         mc_writel((mc_override | MC_EMEM_ARB_OVERRIDE_EACK_MASK),
372                         MC_EMEM_ARB_OVERRIDE);
373 }
374
375 static inline bool dqs_preset(const struct tegra30_emc_table *next_timing,
376                               const struct tegra30_emc_table *last_timing)
377 {
378         bool ret = false;
379
380 #define DQS_SET(reg, bit)                                                     \
381         do {                                                                  \
382                 if ((next_timing->burst_regs[EMC_##reg##_INDEX] &             \
383                      EMC_##reg##_##bit##_ENABLE) &&                           \
384                     (!(last_timing->burst_regs[EMC_##reg##_INDEX] &           \
385                        EMC_##reg##_##bit##_ENABLE)))   {                      \
386                         emc_writel(last_timing->burst_regs[EMC_##reg##_INDEX] \
387                                    | EMC_##reg##_##bit##_ENABLE, EMC_##reg);  \
388                         ret = true;                                           \
389                 }                                                             \
390         } while (0)
391
392         DQS_SET(XM2DQSPADCTRL2, VREF);
393         DQS_SET(XM2DQSPADCTRL3, VREF);
394         DQS_SET(XM2QUSEPADCTRL, IVREF);
395
396         return ret;
397 }
398
399 static inline void overwrite_mrs_wait_cnt(
400         const struct tegra30_emc_table *next_timing,
401         bool zcal_long)
402 {
403         u32 reg;
404         u32 cnt = 512;
405
406         /* For ddr3 when DLL is re-started: overwrite EMC DFS table settings
407            for MRS_WAIT_LONG with maximum of MRS_WAIT_SHORT settings and
408            expected operation length. Reduce the latter by the overlapping
409            zq-calibration, if any */
410         if (zcal_long)
411                 cnt -= dram_dev_num * 256;
412
413         reg = (next_timing->burst_regs[EMC_MRS_WAIT_CNT_INDEX] &
414                 EMC_MRS_WAIT_CNT_SHORT_WAIT_MASK) >>
415                 EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT;
416         if (cnt < reg)
417                 cnt = reg;
418
419         reg = (next_timing->burst_regs[EMC_MRS_WAIT_CNT_INDEX] &
420                 (~EMC_MRS_WAIT_CNT_LONG_WAIT_MASK));
421         reg |= (cnt << EMC_MRS_WAIT_CNT_LONG_WAIT_SHIFT) &
422                 EMC_MRS_WAIT_CNT_LONG_WAIT_MASK;
423
424         emc_writel(reg, EMC_MRS_WAIT_CNT);
425 }
426
427 static inline bool need_qrst(const struct tegra30_emc_table *next_timing,
428                              const struct tegra30_emc_table *last_timing,
429                              u32 emc_dpd_reg)
430 {
431         u32 last_mode = (last_timing->burst_regs[EMC_FBIO_CFG5_INDEX] &
432                 EMC_CFG5_QUSE_MODE_MASK) >> EMC_CFG5_QUSE_MODE_SHIFT;
433         u32 next_mode = (next_timing->burst_regs[EMC_FBIO_CFG5_INDEX] &
434                 EMC_CFG5_QUSE_MODE_MASK) >> EMC_CFG5_QUSE_MODE_SHIFT;
435
436         /* QUSE DPD is disabled */
437         bool ret = !(emc_dpd_reg & EMC_SEL_DPD_CTRL_QUSE_DPD_ENABLE) &&
438
439         /* QUSE uses external mode before or after clock change */
440                 (((last_mode != EMC_CFG5_QUSE_MODE_PULSE_INTERN) &&
441                   (last_mode != EMC_CFG5_QUSE_MODE_INTERNAL_LPBK)) ||
442                  ((next_mode != EMC_CFG5_QUSE_MODE_PULSE_INTERN) &&
443                   (next_mode != EMC_CFG5_QUSE_MODE_INTERNAL_LPBK)))  &&
444
445         /* QUSE pad switches from schmitt to vref mode */
446                 (((last_timing->burst_regs[EMC_XM2QUSEPADCTRL_INDEX] &
447                    EMC_XM2QUSEPADCTRL_IVREF_ENABLE) == 0) &&
448                  ((next_timing->burst_regs[EMC_XM2QUSEPADCTRL_INDEX] &
449                    EMC_XM2QUSEPADCTRL_IVREF_ENABLE) != 0));
450
451         return ret;
452 }
453
454 static inline void periodic_qrst_enable(u32 emc_cfg_reg, u32 emc_dbg_reg)
455 {
456         /* enable write mux => enable periodic QRST => restore mux */
457         emc_writel(emc_dbg_reg | EMC_DBG_WRITE_MUX_ACTIVE, EMC_DBG);
458         emc_writel(emc_cfg_reg | EMC_CFG_PERIODIC_QRST, EMC_CFG);
459         emc_writel(emc_dbg_reg, EMC_DBG);
460 }
461
462 static inline int get_dll_change(const struct tegra30_emc_table *next_timing,
463                                  const struct tegra30_emc_table *last_timing)
464 {
465         bool next_dll_enabled = !(next_timing->emc_mode_1 & 0x1);
466         bool last_dll_enabled = !(last_timing->emc_mode_1 & 0x1);
467
468         if (next_dll_enabled == last_dll_enabled)
469                 return DLL_CHANGE_NONE;
470         else if (next_dll_enabled)
471                 return DLL_CHANGE_ON;
472         else
473                 return DLL_CHANGE_OFF;
474 }
475
476 static inline void set_dram_mode(const struct tegra30_emc_table *next_timing,
477                                  const struct tegra30_emc_table *last_timing,
478                                  int dll_change)
479 {
480         if (dram_type == DRAM_TYPE_DDR3) {
481                 /* first mode_1, then mode_2, then mode_reset*/
482                 if (next_timing->emc_mode_1 != last_timing->emc_mode_1)
483                         emc_writel(next_timing->emc_mode_1, EMC_EMRS);
484                 if (next_timing->emc_mode_2 != last_timing->emc_mode_2)
485                         emc_writel(next_timing->emc_mode_2, EMC_EMRS);
486
487                 if ((next_timing->emc_mode_reset !=
488                      last_timing->emc_mode_reset) ||
489                     (dll_change == DLL_CHANGE_ON))
490                 {
491                         u32 reg = next_timing->emc_mode_reset &
492                                 (~EMC_MODE_SET_DLL_RESET);
493                         if (dll_change == DLL_CHANGE_ON) {
494                                 reg |= EMC_MODE_SET_DLL_RESET;
495                                 reg |= EMC_MODE_SET_LONG_CNT;
496                         }
497                         emc_writel(reg, EMC_MRS);
498                 }
499         } else {
500                 /* first mode_2, then mode_1; mode_reset is not applicable */
501                 if (next_timing->emc_mode_2 != last_timing->emc_mode_2)
502                         emc_writel(next_timing->emc_mode_2, EMC_MRW);
503                 if (next_timing->emc_mode_1 != last_timing->emc_mode_1)
504                         emc_writel(next_timing->emc_mode_1, EMC_MRW);
505         }
506 }
507
508 static inline void do_clock_change(u32 clk_setting)
509 {
510         int err;
511
512         mc_readl(MC_EMEM_ADR_CFG);      /* completes prev writes */
513         writel(clk_setting, clk_base + emc->reg);
514         readl(clk_base + emc->reg);/* completes prev write */
515
516         err = wait_for_update(EMC_INTSTATUS,
517                               EMC_INTSTATUS_CLKCHANGE_COMPLETE, true);
518         if (err) {
519                 pr_err("%s: clock change completion error: %d", __func__, err);
520                 BUG();
521         }
522 }
523
524 static noinline void emc_set_clock(const struct tegra30_emc_table *next_timing,
525                                    const struct tegra30_emc_table *last_timing,
526                                    u32 clk_setting)
527 {
528         int i, dll_change, pre_wait;
529         bool dyn_sref_enabled, vref_cal_toggle, qrst_used, zcal_long;
530
531         u32 mc_override = mc_readl(MC_EMEM_ARB_OVERRIDE);
532         u32 emc_cfg_reg = emc_readl(EMC_CFG);
533         u32 emc_dbg_reg = emc_readl(EMC_DBG);
534
535         dyn_sref_enabled = emc_cfg_reg & EMC_CFG_DYN_SREF_ENABLE;
536         dll_change = get_dll_change(next_timing, last_timing);
537         zcal_long = (next_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] != 0) &&
538                 (last_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] == 0);
539
540         /* FIXME: remove steps enumeration below? */
541
542         /* 1. clear clkchange_complete interrupts */
543         emc_writel(EMC_INTSTATUS_CLKCHANGE_COMPLETE, EMC_INTSTATUS);
544
545         /* 2. disable dynamic self-refresh and preset dqs vref, then wait for
546            possible self-refresh entry/exit and/or dqs vref settled - waiting
547            before the clock change decreases worst case change stall time */
548         pre_wait = 0;
549         if (dyn_sref_enabled) {
550                 emc_cfg_reg &= ~EMC_CFG_DYN_SREF_ENABLE;
551                 emc_writel(emc_cfg_reg, EMC_CFG);
552                 pre_wait = 5;           /* 5us+ for self-refresh entry/exit */
553         }
554
555         /* 2.25 update MC arbiter settings */
556         set_mc_arbiter_limits();
557         if (mc_override & MC_EMEM_ARB_OVERRIDE_EACK_MASK)
558                 disable_early_ack(mc_override);
559
560         /* 2.5 check dq/dqs vref delay */
561         if (dqs_preset(next_timing, last_timing)) {
562                 if (pre_wait < 3)
563                         pre_wait = 3;   /* 3us+ for dqs vref settled */
564         }
565         if (pre_wait) {
566                 emc_timing_update();
567                 udelay(pre_wait);
568         }
569
570         /* 3. disable auto-cal if vref mode is switching */
571         vref_cal_toggle = (next_timing->emc_acal_interval != 0) &&
572                 ((next_timing->burst_regs[EMC_XM2COMPPADCTRL_INDEX] ^
573                   last_timing->burst_regs[EMC_XM2COMPPADCTRL_INDEX]) &
574                  EMC_XM2COMPPADCTRL_VREF_CAL_ENABLE);
575         if (vref_cal_toggle)
576                 auto_cal_disable();
577
578         /* 4. program burst shadow registers */
579         for (i = 0; i < emc_num_burst_regs; i++) {
580                 if (!burst_reg_addr[i])
581                         continue;
582                 __raw_writel(next_timing->burst_regs[i], burst_reg_addr[i]);
583         }
584         if ((dram_type == DRAM_TYPE_LPDDR2) &&
585             (dram_over_temp_state != DRAM_OVER_TEMP_NONE))
586                 set_over_temp_timing(next_timing, dram_over_temp_state);
587         wmb();
588         barrier();
589
590         /* On ddr3 when DLL is re-started predict MRS long wait count and
591            overwrite DFS table setting */
592         if ((dram_type == DRAM_TYPE_DDR3) && (dll_change == DLL_CHANGE_ON))
593                 overwrite_mrs_wait_cnt(next_timing, zcal_long);
594
595         /* the last read below makes sure prev writes are completed */
596         qrst_used = need_qrst(next_timing, last_timing,
597                               emc_readl(EMC_SEL_DPD_CTRL));
598
599         /* 5. flow control marker 1 (no EMC read access after this) */
600         emc_writel(1, EMC_STALL_BEFORE_CLKCHANGE);
601
602         /* 6. enable periodic QRST */
603         if (qrst_used)
604                 periodic_qrst_enable(emc_cfg_reg, emc_dbg_reg);
605
606         /* 6.1 disable auto-refresh to save time after clock change */
607         emc_writel(EMC_REFCTRL_DISABLE_ALL(dram_dev_num), EMC_REFCTRL);
608
609         /* 7. turn Off dll and enter self-refresh on DDR3 */
610         if (dram_type == DRAM_TYPE_DDR3) {
611                 if (dll_change == DLL_CHANGE_OFF)
612                         emc_writel(next_timing->emc_mode_1, EMC_EMRS);
613                 emc_writel(DRAM_BROADCAST(dram_dev_num) |
614                            EMC_SELF_REF_CMD_ENABLED, EMC_SELF_REF);
615         }
616
617         /* 8. flow control marker 2 */
618         emc_writel(1, EMC_STALL_AFTER_CLKCHANGE);
619
620         /* 8.1 enable write mux, update unshadowed pad control */
621         emc_writel(emc_dbg_reg | EMC_DBG_WRITE_MUX_ACTIVE, EMC_DBG);
622         emc_writel(next_timing->burst_regs[EMC_XM2CLKPADCTRL_INDEX],
623                    EMC_XM2CLKPADCTRL);
624
625         /* 9. restore periodic QRST, and disable write mux */
626         if ((qrst_used) || (next_timing->emc_periodic_qrst !=
627                             last_timing->emc_periodic_qrst)) {
628                 emc_cfg_reg = next_timing->emc_periodic_qrst ?
629                         emc_cfg_reg | EMC_CFG_PERIODIC_QRST :
630                         emc_cfg_reg & (~EMC_CFG_PERIODIC_QRST);
631                 emc_writel(emc_cfg_reg, EMC_CFG);
632         }
633         emc_writel(emc_dbg_reg, EMC_DBG);
634
635         /* 10. exit self-refresh on DDR3 */
636         if (dram_type == DRAM_TYPE_DDR3)
637                 emc_writel(DRAM_BROADCAST(dram_dev_num), EMC_SELF_REF);
638
639         /* 11. set dram mode registers */
640         set_dram_mode(next_timing, last_timing, dll_change);
641
642         /* 12. issue zcal command if turning zcal On */
643         if (zcal_long) {
644                 emc_writel(EMC_ZQ_CAL_LONG_CMD_DEV0, EMC_ZQ_CAL);
645                 if (dram_dev_num > 1)
646                         emc_writel(EMC_ZQ_CAL_LONG_CMD_DEV1, EMC_ZQ_CAL);
647         }
648
649         /* 13. flow control marker 3 */
650         emc_writel(1, EMC_UNSTALL_RW_AFTER_CLKCHANGE);
651
652         /* 14. read any MC register to ensure the programming is done
653                change EMC clock source register (EMC read access restored)
654                wait for clk change completion */
655         do_clock_change(clk_setting);
656
657         /* 14.1 re-enable auto-refresh */
658         emc_writel(EMC_REFCTRL_ENABLE_ALL(dram_dev_num), EMC_REFCTRL);
659
660         /* 15. restore auto-cal */
661         if (vref_cal_toggle)
662                 emc_writel(next_timing->emc_acal_interval,
663                            EMC_AUTO_CAL_INTERVAL);
664
665         /* 16. restore dynamic self-refresh */
666         if (next_timing->rev >= 0x32)
667                 dyn_sref_enabled = next_timing->emc_dsr;
668         if (dyn_sref_enabled) {
669                 emc_cfg_reg |= EMC_CFG_DYN_SREF_ENABLE;
670                 emc_writel(emc_cfg_reg, EMC_CFG);
671         }
672
673         /* 17. set zcal wait count */
674         if (zcal_long)
675                 emc_writel(next_timing->emc_zcal_cnt_long, EMC_ZCAL_WAIT_CNT);
676
677         /* 18. update restored timing */
678         udelay(2);
679         emc_timing_update();
680
681         /* 18.a restore early ACK */
682         mc_writel(mc_override, MC_EMEM_ARB_OVERRIDE);
683 }
684
685 static inline void emc_get_timing(struct tegra30_emc_table *timing)
686 {
687         int i;
688
689         for (i = 0; i < emc_num_burst_regs; i++) {
690                 if (burst_reg_addr[i])
691                         timing->burst_regs[i] = __raw_readl(burst_reg_addr[i]);
692                 else
693                         timing->burst_regs[i] = 0;
694         }
695         timing->emc_acal_interval = 0;
696         timing->emc_zcal_cnt_long = 0;
697         timing->emc_mode_reset = 0;
698         timing->emc_mode_1 = 0;
699         timing->emc_mode_2 = 0;
700         timing->emc_periodic_qrst = (emc_readl(EMC_CFG) &
701                                      EMC_CFG_PERIODIC_QRST) ? 1 : 0;
702 }
703
704 /* After deep sleep EMC power features are not restored.
705  * Do it at run-time after the 1st clock change.
706  */
707 static inline void emc_cfg_power_restore(void)
708 {
709         u32 reg = emc_readl(EMC_CFG);
710         u32 pwr_mask = EMC_CFG_PWR_MASK;
711
712         if (tegra_emc_table[0].rev >= 0x32)
713                 pwr_mask &= ~EMC_CFG_DYN_SREF_ENABLE;
714
715         if ((reg ^ emc_cfg_saved) & pwr_mask) {
716                 reg = (reg & (~pwr_mask)) | (emc_cfg_saved & pwr_mask);
717                 emc_writel(reg, EMC_CFG);
718                 emc_timing_update();
719         }
720 }
721
722 /* The EMC registers have shadow registers. When the EMC clock is updated
723  * in the clock controller, the shadow registers are copied to the active
724  * registers, allowing glitchless memory bus frequency changes.
725  * This function updates the shadow registers for a new clock frequency,
726  * and relies on the clock lock on the emc clock to avoid races between
727  * multiple frequency changes */
728 static int emc_set_rate(unsigned long rate, bool use_backup)
729 {
730         int i;
731         u32 clk_setting;
732         const struct tegra30_emc_table *last_timing;
733         unsigned long flags;
734
735         if (!tegra_emc_table)
736                 return -EINVAL;
737
738         /* Table entries specify rate in kHz */
739         rate = rate / 1000;
740
741         for (i = 0; i < tegra_emc_table_size; i++) {
742                 if (tegra_emc_clk_sel[i].input == NULL)
743                         continue;       /* invalid entry */
744
745                 if (tegra_emc_table[i].rate == rate)
746                         break;
747         }
748
749         if (i >= tegra_emc_table_size)
750                 return -EINVAL;
751
752         if (!emc_timing) {
753                 /* can not assume that boot timing matches dfs table even
754                    if boot frequency matches one of the table nodes */
755                 emc_get_timing(&start_timing);
756                 last_timing = &start_timing;
757         }
758         else
759                 last_timing = emc_timing;
760
761         clk_setting = use_backup ? emc->shared_bus_backup.value :
762                 tegra_emc_clk_sel[i].value;
763
764         spin_lock_irqsave(&emc_access_lock, flags);
765         emc_set_clock(&tegra_emc_table[i], last_timing, clk_setting);
766         if (!emc_timing)
767                 emc_cfg_power_restore();
768         emc_timing = &tegra_emc_table[i];
769         spin_unlock_irqrestore(&emc_access_lock, flags);
770
771         emc_last_stats_update(i);
772
773         pr_debug("%s: rate %lu setting 0x%x\n", __func__, rate, clk_setting);
774
775         return 0;
776 }
777
778 int tegra_emc_set_rate(unsigned long rate)
779 {
780         return emc_set_rate(rate, false);
781 }
782
783 int tegra_emc_backup(unsigned long rate)
784 {
785         BUG_ON(rate != emc->shared_bus_backup.bus_rate);
786         return emc_set_rate(rate, true);
787 }
788
789 /* Select the closest EMC rate that is higher than the requested rate */
790 long tegra_emc_round_rate(unsigned long rate)
791 {
792         int i;
793         int best = -1;
794         unsigned long distance = ULONG_MAX;
795
796         if (!tegra_emc_table)
797                 return clk_get_rate_locked(emc); /* no table - no rate change */
798
799         if (!emc_enable)
800                 return -EINVAL;
801
802         pr_debug("%s: %lu\n", __func__, rate);
803
804         /* Table entries specify rate in kHz */
805         rate = rate / 1000;
806
807         for (i = 0; i < tegra_emc_table_size; i++) {
808                 if (tegra_emc_clk_sel[i].input == NULL)
809                         continue;       /* invalid entry */
810
811                 if (tegra_emc_table[i].rate >= rate &&
812                     (tegra_emc_table[i].rate - rate) < distance) {
813                         distance = tegra_emc_table[i].rate - rate;
814                         best = i;
815                 }
816         }
817
818         if (best < 0)
819                 return -EINVAL;
820
821         pr_debug("%s: using %lu\n", __func__, tegra_emc_table[best].rate);
822
823         return tegra_emc_table[best].rate * 1000;
824 }
825
826 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
827 {
828         int i;
829
830         if (!tegra_emc_table)
831                 return ERR_PTR(-ENOENT);
832
833         pr_debug("%s: %lu\n", __func__, rate);
834
835         /* Table entries specify rate in kHz */
836         rate = rate / 1000;
837
838         for (i = 0; i < tegra_emc_table_size; i++) {
839                 if (tegra_emc_table[i].rate == rate) {
840                         struct clk *p = tegra_emc_clk_sel[i].input;
841
842                         *div_value = (tegra_emc_clk_sel[i].value &
843                                 EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
844                         if (tegra_emc_clk_sel[i].input_rate != clk_get_rate(p))
845                                 return NULL;
846
847                         return p;
848                 }
849         }
850         return ERR_PTR(-ENOENT);
851 }
852
853 int find_matching_input(unsigned long table_rate, bool mc_same_freq,
854                         struct emc_sel *emc_clk_sel, struct clk *cbus)
855 {
856         u32 div_value = 0;
857         unsigned long input_rate = 0;
858         const struct clk_mux_sel *sel;
859         const struct clk_mux_sel *parent_sel = NULL;
860         const struct clk_mux_sel *backup_sel = NULL;
861
862         /* Table entries specify rate in kHz */
863         table_rate *= 1000;
864
865         for (sel = emc->inputs; sel->input != NULL; sel++) {
866                 if (sel->input == emc->shared_bus_backup.input) {
867                         backup_sel = sel;
868                         continue;       /* skip backup souce */
869                 }
870
871                 if (sel->input == emc->parent)
872                         parent_sel = sel;
873
874                 input_rate = clk_get_rate(sel->input);
875
876                 if ((input_rate >= table_rate) &&
877                      (input_rate % table_rate == 0)) {
878                         div_value = 2 * input_rate / table_rate - 2;
879                         break;
880                 }
881         }
882
883 #ifdef CONFIG_TEGRA_PLLM_RESTRICTED
884         /*
885          * When match not found, check if this rate can be backed-up by cbus
886          * Then, we will be able to re-lock boot parent PLLM, and use it as
887          * an undivided source. Backup is supported only on LPDDR2 platforms
888          * with restricted PLLM usage. Just one backup entry is recognized,
889          * and it must be between EMC maximum and half maximum rates.
890          */
891         if ((dram_type == DRAM_TYPE_LPDDR2) && (sel->input == NULL) &&
892             (emc->shared_bus_backup.bus_rate == 0) && cbus) {
893                 BUG_ON(!parent_sel || !backup_sel);
894
895                 if ((table_rate == clk_round_rate(cbus, table_rate)) &&
896                     (table_rate < clk_get_max_rate(emc)) &&
897                     (table_rate >= clk_get_max_rate(emc) / 2)) {
898                         emc->shared_bus_backup.bus_rate = table_rate;
899
900                         /* Get ready emc clock backup selection settings */
901                         emc->shared_bus_backup.value =
902                                 (backup_sel->value << EMC_CLK_SOURCE_SHIFT) |
903                                 (cbus->div << EMC_CLK_DIV_SHIFT) |
904                                 (mc_same_freq ? EMC_CLK_MC_SAME_FREQ : 0);
905
906                         /* Select undivided PLLM as regular source */
907                         sel = parent_sel;
908                         input_rate = table_rate;
909                         div_value = 0;
910                 }
911         }
912 #endif
913
914         if (sel->input) {
915                 emc_clk_sel->input = sel->input;
916                 emc_clk_sel->input_rate = input_rate;
917
918                 /* Get ready emc clock selection settings for this table rate */
919                 emc_clk_sel->value = sel->value << EMC_CLK_SOURCE_SHIFT;
920                 emc_clk_sel->value |= (div_value << EMC_CLK_DIV_SHIFT);
921                 if ((div_value == 0) && (emc_clk_sel->input == emc->parent))
922                         emc_clk_sel->value |= EMC_CLK_LOW_JITTER_ENABLE;
923                 if (mc_same_freq)
924                         emc_clk_sel->value |= EMC_CLK_MC_SAME_FREQ;
925                 return 0;
926         }
927         return -EINVAL;
928 }
929
930 static void adjust_emc_dvfs_table(const struct tegra30_emc_table *table,
931                                   int table_size)
932 {
933         int i, j;
934         unsigned long rate;
935
936         if (table[0].rev < 0x33)
937                 return;
938
939         for (i = 0; i < MAX_DVFS_FREQS; i++) {
940                 int mv = emc->dvfs->millivolts[i];
941                 if (!mv)
942                         break;
943
944                 /* For each dvfs voltage find maximum supported rate;
945                    use 1MHz placeholder if not found */
946                 for (rate = 1000, j = 0; j < table_size; j++) {
947                         if (tegra_emc_clk_sel[j].input == NULL)
948                                 continue;       /* invalid entry */
949
950                         if ((mv >= table[j].emc_min_mv) &&
951                             (rate < table[j].rate))
952                                 rate = table[j].rate;
953                 }
954                 /* Table entries specify rate in kHz */
955                 emc->dvfs->freqs[i] = rate * 1000;
956         }
957 }
958
959 static bool is_emc_bridge(void)
960 {
961         int mv;
962         unsigned long rate;
963
964         bridge = tegra_get_clock_by_name("bridge.emc");
965         BUG_ON(!bridge);
966
967         /* LPDDR2 does not need a bridge entry in DFS table: just lock bridge
968            rate at minimum so it won't interfere with emc bus operations */
969         if (dram_type == DRAM_TYPE_LPDDR2) {
970                 clk_set_rate(bridge, 0);
971                 return true;
972         }
973
974         /* DDR3 requires EMC DFS table to include a bridge entry with frequency
975            above minimum bridge threshold, and voltage below bridge threshold */
976         rate = clk_round_rate(bridge, TEGRA_EMC_BRIDGE_RATE_MIN);
977         if (IS_ERR_VALUE(rate))
978                 return false;
979
980         mv = tegra_dvfs_predict_millivolts(emc, rate);
981         if (IS_ERR_VALUE(mv) || (mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN))
982                 return false;
983
984         if (clk_set_rate(bridge, rate))
985                 return false;
986
987         return true;
988 }
989
990 static int tegra_emc_suspend_notify(struct notifier_block *nb,
991                                 unsigned long event, void *data)
992 {
993         if (event != PM_SUSPEND_PREPARE)
994                 return NOTIFY_OK;
995
996         if (dram_type == DRAM_TYPE_DDR3) {
997                 if (clk_prepare_enable(bridge)) {
998                         pr_info("Tegra emc suspend:"
999                                 " failed to enable bridge.emc\n");
1000                         return NOTIFY_STOP;
1001                 }
1002                 pr_info("Tegra emc suspend: enabled bridge.emc\n");
1003         }
1004         return NOTIFY_OK;
1005 };
1006 static struct notifier_block tegra_emc_suspend_nb = {
1007         .notifier_call = tegra_emc_suspend_notify,
1008         .priority = 2,
1009 };
1010
1011 static int tegra_emc_resume_notify(struct notifier_block *nb,
1012                                 unsigned long event, void *data)
1013 {
1014         if (event != PM_POST_SUSPEND)
1015                 return NOTIFY_OK;
1016
1017         if (dram_type == DRAM_TYPE_DDR3) {
1018                 clk_disable_unprepare(bridge);
1019                 pr_info("Tegra emc resume: disabled bridge.emc\n");
1020         }
1021         return NOTIFY_OK;
1022 };
1023 static struct notifier_block tegra_emc_resume_nb = {
1024         .notifier_call = tegra_emc_resume_notify,
1025         .priority = -1,
1026 };
1027
1028 static int tegra_emc_get_table_ns_per_tick(unsigned int emc_rate,
1029                                         unsigned int table_tick_len)
1030 {
1031         unsigned int ns_per_tick = 0;
1032         unsigned int mc_period_10ns = 0;
1033         unsigned int reg;
1034
1035         reg = mc_readl(MC_EMEM_ARB_MISC0) & MC_EMEM_ARB_MISC0_EMC_SAME_FREQ;
1036
1037         mc_period_10ns = ((reg ? (NSEC_PER_MSEC * 10) : (20 * NSEC_PER_MSEC)) /
1038                         (emc_rate));
1039         ns_per_tick = ((table_tick_len & MC_EMEM_ARB_CFG_CYCLE_MASK)
1040                 * mc_period_10ns) / (10 *
1041                 (1 + ((table_tick_len & MC_EMEM_ARB_CFG_EXTRA_TICK_MASK)
1042                 >> MC_EMEM_ARB_CFG_EXTRA_TICK_SHIFT)));
1043
1044         /* round new_ns_per_tick to 30/60 */
1045         if (ns_per_tick < 45)
1046                 ns_per_tick = 30;
1047         else
1048                 ns_per_tick = 60;
1049
1050         return ns_per_tick;
1051 }
1052
1053 #ifdef CONFIG_OF
1054 static struct device_node *tegra_emc_ramcode_devnode(struct device_node *np)
1055 {
1056         struct device_node *iter;
1057         u32 reg;
1058
1059         for_each_child_of_node(np, iter) {
1060                 if (of_property_read_u32(np, "nvidia,ram-code", &reg))
1061                         continue;
1062                 if (reg == tegra_bct_strapping)
1063                         return of_node_get(iter);
1064         }
1065
1066         return NULL;
1067 }
1068
1069 static struct tegra30_emc_pdata *tegra_emc_dt_parse_pdata(
1070                 struct platform_device *pdev)
1071 {
1072         struct device_node *np = pdev->dev.of_node;
1073         struct device_node *tnp, *iter;
1074         struct tegra30_emc_pdata *pdata;
1075         int ret, i, num_tables;
1076
1077         if (!np)
1078                 return NULL;
1079
1080         if (of_find_property(np, "nvidia,use-ram-code", NULL)) {
1081                 tnp = tegra_emc_ramcode_devnode(np);
1082                 if (!tnp)
1083                         dev_warn(&pdev->dev,
1084                                 "can't find emc table for ram-code 0x%02x\n",
1085                                         tegra_bct_strapping);
1086         } else
1087                 tnp = of_node_get(np);
1088
1089         if (!tnp)
1090                 return NULL;
1091
1092         num_tables = 0;
1093         for_each_child_of_node(tnp, iter)
1094                 if (of_device_is_compatible(iter, "nvidia,tegra30-emc-table"))
1095                         num_tables++;
1096
1097         if (!num_tables) {
1098                 pdata = NULL;
1099                 goto out;
1100         }
1101
1102         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1103         pdata->tables = devm_kzalloc(&pdev->dev,
1104                                 sizeof(*pdata->tables) * num_tables,
1105                                         GFP_KERNEL);
1106
1107         i = 0;
1108         for_each_child_of_node(tnp, iter) {
1109                 u32 u;
1110                 int num_burst_regs;
1111                 struct property *prop;
1112
1113                 ret = of_property_read_u32(iter, "nvidia,revision", &u);
1114                 if (ret) {
1115                         dev_err(&pdev->dev, "no revision in %s\n",
1116                                 iter->full_name);
1117                         continue;
1118                 }
1119                 pdata->tables[i].rev = u;
1120
1121                 ret = of_property_read_u32(iter, "clock-frequency", &u);
1122                 if (ret) {
1123                         dev_err(&pdev->dev, "no clock-frequency in %s\n",
1124                                 iter->full_name);
1125                         continue;
1126                 }
1127                 pdata->tables[i].rate = u;
1128
1129                 prop = of_find_property(iter, "nvidia,emc-registers", NULL);
1130                 if (!prop)
1131                         continue;
1132
1133                 num_burst_regs = prop->length / sizeof(u);
1134
1135                 ret = of_property_read_u32_array(iter, "nvidia,emc-registers",
1136                                                 pdata->tables[i].burst_regs,
1137                                                         num_burst_regs);
1138                 if (ret) {
1139                         dev_err(&pdev->dev,
1140                                 "malformed emc-registers property in %s\n",
1141                                 iter->full_name);
1142                         continue;
1143                 }
1144
1145                 of_property_read_u32(iter, "nvidia,emc-zcal-cnt-long",
1146                                         &pdata->tables[i].emc_zcal_cnt_long);
1147                 of_property_read_u32(iter, "nvidia,emc-acal-interval",
1148                                         &pdata->tables[i].emc_acal_interval);
1149                 of_property_read_u32(iter, "nvidia,emc-periodic-qrst",
1150                                         &pdata->tables[i].emc_periodic_qrst);
1151                 of_property_read_u32(iter, "nvidia,emc-mode-reset",
1152                                         &pdata->tables[i].emc_mode_reset);
1153                 of_property_read_u32(iter, "nvidia,emc-mode-1",
1154                                         &pdata->tables[i].emc_mode_1);
1155                 of_property_read_u32(iter, "nvidia,emc-mode-2",
1156                                         &pdata->tables[i].emc_mode_2);
1157                 of_property_read_u32(iter, "nvidia,emc-dsr",
1158                                         &pdata->tables[i].emc_dsr);
1159
1160                 ret = of_property_read_u32(iter, "nvidia,emc-min-mv", &u);
1161                 if (!ret)
1162                         pdata->tables[i].emc_min_mv = u;
1163
1164                 i++;
1165         }
1166         pdata->num_tables = i;
1167
1168 out:
1169         of_node_put(tnp);
1170         return pdata;
1171 }
1172 #else
1173 static struct tegra_emc_pdata *tegra_emc_dt_parse_pdata(
1174                                         struct platform_device *pdev)
1175 {
1176         return NULL;
1177 }
1178 #endif
1179
1180 static int __devinit tegra30_emc_probe(struct platform_device *pdev)
1181 {
1182         int i, mv;
1183         u32 reg;
1184         bool max_entry = false;
1185         unsigned long boot_rate, max_rate;
1186         struct clk *cbus = tegra_get_clock_by_name("cbus");
1187         unsigned int ns_per_tick = 0;
1188         unsigned int cur_ns_per_tick = 0;
1189         struct tegra30_emc_pdata *pdata;
1190         struct resource *res;
1191
1192         if (tegra_emc_table)
1193                 return -EINVAL;
1194
1195         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1196         if (!res) {
1197                 dev_err(&pdev->dev, "missing register base\n");
1198                 return -ENOMEM;
1199         }
1200
1201         pdata = pdev->dev.platform_data;
1202
1203         if (!pdata)
1204                 pdata = tegra_emc_dt_parse_pdata(pdev);
1205
1206         pdev->dev.platform_data = pdata;
1207
1208         emc_stats.clkchange_count = 0;
1209         spin_lock_init(&emc_stats.spinlock);
1210         emc_stats.last_update = get_jiffies_64();
1211         emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
1212
1213         boot_rate = clk_get_rate(emc) / 1000;
1214         max_rate = clk_get_max_rate(emc) / 1000;
1215
1216         if ((dram_type != DRAM_TYPE_DDR3) && (dram_type != DRAM_TYPE_LPDDR2)) {
1217                 pr_err("tegra: not supported DRAM type %u\n", dram_type);
1218                 return -ENODATA;
1219         }
1220
1221         if (emc->parent != tegra_get_clock_by_name("pll_m")) {
1222                 pr_err("tegra: boot parent %s is not supported by EMC DFS\n",
1223                         emc->parent->name);
1224                 return -ENODATA;
1225         }
1226
1227         if (!pdata || !pdata->tables || !pdata->num_tables) {
1228                 pr_err("tegra: EMC DFS table is empty\n");
1229                 return -ENODATA;
1230         }
1231
1232         tegra_emc_table_size = min(pdata->num_tables, TEGRA_EMC_TABLE_MAX_SIZE);
1233         switch (pdata->tables[0].rev) {
1234         case 0x30:
1235                 emc_num_burst_regs = 105;
1236                 break;
1237         case 0x31:
1238         case 0x32:
1239         case 0x33:
1240                 emc_num_burst_regs = 107;
1241                 break;
1242         default:
1243                 pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
1244                         pdata->tables[0].rev);
1245                 return -ENODATA;
1246         }
1247
1248         /* Match EMC source/divider settings with table entries */
1249         for (i = 0; i < tegra_emc_table_size; i++) {
1250                 bool mc_same_freq = MC_EMEM_ARB_MISC0_EMC_SAME_FREQ &
1251                         pdata->tables[i].burst_regs[MC_EMEM_ARB_MISC0_INDEX];
1252                 unsigned long table_rate = pdata->tables[i].rate;
1253                 if (!table_rate)
1254                         continue;
1255
1256                 BUG_ON(pdata->tables[i].rev != pdata->tables[0].rev);
1257
1258                 if (find_matching_input(table_rate, mc_same_freq,
1259                                         &tegra_emc_clk_sel[i], cbus))
1260                         continue;
1261
1262                 if (table_rate == boot_rate)
1263                         emc_stats.last_sel = i;
1264
1265                 if (table_rate == max_rate)
1266                         max_entry = true;
1267
1268                 cur_ns_per_tick = tegra_emc_get_table_ns_per_tick(table_rate,
1269                         pdata->tables[i].burst_regs[MC_EMEM_ARB_CFG_INDEX]);
1270
1271                 if (ns_per_tick == 0) {
1272                         ns_per_tick = cur_ns_per_tick;
1273                 } else if (ns_per_tick != cur_ns_per_tick) {
1274                         pr_err("tegra: invalid EMC DFS table: "
1275                                 "mismatched DFS tick lengths "
1276                                 "within table!\n");
1277                         ns_per_tick = 0;
1278                         return -EINVAL;
1279                 }
1280         }
1281
1282         /* Validate EMC rate and voltage limits */
1283         if (!max_entry) {
1284                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
1285                        " %lu kHz is not found\n", max_rate);
1286                 return -EINVAL;
1287         }
1288
1289         tegra_latency_allowance_update_tick_length(ns_per_tick);
1290
1291         tegra_emc_table = pdata->tables;
1292
1293         adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
1294         mv = tegra_dvfs_predict_millivolts(emc, max_rate * 1000);
1295         if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
1296                 tegra_emc_table = NULL;
1297                 pr_err("tegra: invalid EMC DFS table: maximum rate %lu kHz does"
1298                        " not match nominal voltage %d\n",
1299                                 max_rate, emc->dvfs->max_millivolts);
1300                 return -ENODATA;
1301         }
1302
1303         if (!is_emc_bridge()) {
1304                 tegra_emc_table = NULL;
1305                 pr_err("tegra: invalid EMC DFS table: emc bridge not found");
1306                 return -ENODATA;
1307         }
1308         pr_info("tegra: validated EMC DFS table\n");
1309
1310         /* Configure clock change mode according to dram type */
1311         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
1312         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
1313                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
1314         emc_writel(reg, EMC_CFG_2);
1315
1316         register_pm_notifier(&tegra_emc_suspend_nb);
1317         register_pm_notifier(&tegra_emc_resume_nb);
1318
1319         return 0;
1320 }
1321
1322 static struct of_device_id tegra30_emc_of_match[] __devinitdata = {
1323         { .compatible = "nvidia,tegra30-emc", },
1324         { },
1325 };
1326
1327 static struct platform_driver tegra30_emc_driver = {
1328         .driver = {
1329                 .name = "tegra-emc",
1330                 .owner = THIS_MODULE,
1331                 .of_match_table = tegra30_emc_of_match,
1332         },
1333         .probe = tegra30_emc_probe,
1334 };
1335
1336 int __init tegra30_init_emc(void)
1337 {
1338         return platform_driver_register(&tegra30_emc_driver);
1339 }
1340
1341 void tegra_emc_timing_invalidate(void)
1342 {
1343         emc_timing = NULL;
1344 }
1345
1346 void tegra_init_dram_bit_map(const u32 *bit_map, int map_size)
1347 {
1348         BUG_ON(map_size != 32);
1349         dram_to_soc_bit_map = bit_map;
1350 }
1351
1352 void tegra_emc_dram_type_init(struct clk *c)
1353 {
1354         emc = c;
1355
1356         dram_type = (emc_readl(EMC_FBIO_CFG5) &
1357                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
1358         if (dram_type == DRAM_TYPE_DDR3)
1359                 emc->min_rate = EMC_MIN_RATE_DDR3;
1360
1361         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
1362         emc_cfg_saved = emc_readl(EMC_CFG);
1363 }
1364
1365 int tegra_emc_get_dram_type(void)
1366 {
1367         return dram_type;
1368 }
1369
1370 static u32 soc_to_dram_bit_swap(u32 soc_val, u32 dram_mask, u32 dram_shift)
1371 {
1372         int bit;
1373         u32 dram_val = 0;
1374
1375         /* tegra clocks definitions use shifted mask always */
1376         if (!dram_to_soc_bit_map)
1377                 return soc_val & dram_mask;
1378
1379         for (bit = dram_shift; bit < 32; bit++) {
1380                 u32 dram_bit_mask = 0x1 << bit;
1381                 u32 soc_bit_mask = dram_to_soc_bit_map[bit];
1382
1383                 if (!(dram_bit_mask & dram_mask))
1384                         break;
1385
1386                 if (soc_bit_mask & soc_val)
1387                         dram_val |= dram_bit_mask;
1388         }
1389
1390         return dram_val;
1391 }
1392
1393 static int emc_read_mrr(int dev, int addr)
1394 {
1395         int ret;
1396         u32 val;
1397
1398         if (dram_type != DRAM_TYPE_LPDDR2)
1399                 return -ENODEV;
1400
1401         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, false);
1402         if (ret)
1403                 return ret;
1404
1405         val = dev ? DRAM_DEV_SEL_1 : DRAM_DEV_SEL_0;
1406         val |= (addr << EMC_MRR_MA_SHIFT) & EMC_MRR_MA_MASK;
1407         emc_writel(val, EMC_MRR);
1408
1409         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, true);
1410         if (ret)
1411                 return ret;
1412
1413         val = emc_readl(EMC_MRR) & EMC_MRR_DATA_MASK;
1414         return val;
1415 }
1416
1417 int tegra_emc_get_dram_temperature(void)
1418 {
1419         int mr4;
1420         unsigned long flags;
1421
1422         spin_lock_irqsave(&emc_access_lock, flags);
1423
1424         mr4 = emc_read_mrr(0, 4);
1425         if (IS_ERR_VALUE(mr4)) {
1426                 spin_unlock_irqrestore(&emc_access_lock, flags);
1427                 return mr4;
1428         }
1429         spin_unlock_irqrestore(&emc_access_lock, flags);
1430
1431         mr4 = soc_to_dram_bit_swap(
1432                 mr4, LPDDR2_MR4_TEMP_MASK, LPDDR2_MR4_TEMP_SHIFT);
1433         return mr4;
1434 }
1435
1436 int tegra_emc_set_over_temp_state(unsigned long state)
1437 {
1438         unsigned long flags;
1439
1440         if (dram_type != DRAM_TYPE_LPDDR2)
1441                 return -ENODEV;
1442
1443         spin_lock_irqsave(&emc_access_lock, flags);
1444
1445         /* Update refresh timing if state changed */
1446         if (emc_timing && (dram_over_temp_state != state)) {
1447                 set_over_temp_timing(emc_timing, state);
1448                 emc_timing_update();
1449                 if (state != DRAM_OVER_TEMP_NONE)
1450                         emc_writel(EMC_REF_FORCE_CMD, EMC_REF);
1451                 dram_over_temp_state = state;
1452         }
1453         spin_unlock_irqrestore(&emc_access_lock, flags);
1454         return 0;
1455 }
1456
1457 /* non-zero state value will reduce eack_disable_refcnt */
1458 static int tegra_emc_set_eack_state(unsigned long state)
1459 {
1460         unsigned long flags;
1461         u32 mc_override;
1462         static int eack_disable_refcnt = 0;
1463
1464         spin_lock_irqsave(&emc_access_lock, flags);
1465
1466         /*
1467          * refcnt > 0 implies there is at least one client requiring eack
1468          * disabled. refcnt of 0 implies eack is enabled
1469          */
1470         if (eack_disable_refcnt == 1 && state) {
1471                 mc_override = mc_readl(MC_EMEM_ARB_OVERRIDE);
1472                 enable_early_ack(mc_override);
1473         } else if (eack_disable_refcnt == 0 && !state) {
1474                 mc_override = mc_readl(MC_EMEM_ARB_OVERRIDE);
1475                 disable_early_ack(mc_override);
1476         }
1477
1478         if (state) {
1479                 if (likely(eack_disable_refcnt > 0)) {
1480                         --eack_disable_refcnt;
1481                 } else {
1482                         pr_err("%s: Ignored a request to underflow eack "
1483                                 "disable reference counter\n",__func__);
1484                         dump_stack();
1485                 }
1486         } else {
1487                 ++eack_disable_refcnt;
1488         }
1489
1490         spin_unlock_irqrestore(&emc_access_lock, flags);
1491         return 0;
1492 }
1493
1494 int tegra_emc_enable_eack(void) {
1495         return tegra_emc_set_eack_state(1);
1496 }
1497
1498 int tegra_emc_disable_eack(void) {
1499         return tegra_emc_set_eack_state(0);
1500 }
1501
1502 #ifdef CONFIG_DEBUG_FS
1503
1504 static struct dentry *emc_debugfs_root;
1505
1506 static int emc_stats_show(struct seq_file *s, void *data)
1507 {
1508         int i;
1509
1510         emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE);
1511
1512         seq_printf(s, "%-10s %-10s \n", "rate kHz", "time");
1513         for (i = 0; i < tegra_emc_table_size; i++) {
1514                 if (tegra_emc_clk_sel[i].input == NULL)
1515                         continue;       /* invalid entry */
1516
1517                 seq_printf(s, "%-10lu %-10llu \n", tegra_emc_table[i].rate,
1518                            cputime64_to_clock_t(emc_stats.time_at_clock[i]));
1519         }
1520         seq_printf(s, "%-15s %llu\n", "transitions:",
1521                    emc_stats.clkchange_count);
1522         seq_printf(s, "%-15s %llu\n", "time-stamp:",
1523                    cputime64_to_clock_t(emc_stats.last_update));
1524
1525         return 0;
1526 }
1527
1528 static int emc_stats_open(struct inode *inode, struct file *file)
1529 {
1530         return single_open(file, emc_stats_show, inode->i_private);
1531 }
1532
1533 static const struct file_operations emc_stats_fops = {
1534         .open           = emc_stats_open,
1535         .read           = seq_read,
1536         .llseek         = seq_lseek,
1537         .release        = single_release,
1538 };
1539
1540 static int dram_temperature_get(void *data, u64 *val)
1541 {
1542         *val = tegra_emc_get_dram_temperature();
1543         return 0;
1544 }
1545 DEFINE_SIMPLE_ATTRIBUTE(dram_temperature_fops, dram_temperature_get,
1546                         NULL, "%lld\n");
1547
1548 static int over_temp_state_get(void *data, u64 *val)
1549 {
1550         *val = dram_over_temp_state;
1551         return 0;
1552 }
1553 static int over_temp_state_set(void *data, u64 val)
1554 {
1555         tegra_emc_set_over_temp_state(val);
1556         return 0;
1557 }
1558 DEFINE_SIMPLE_ATTRIBUTE(over_temp_state_fops, over_temp_state_get,
1559                         over_temp_state_set, "%llu\n");
1560
1561 static int eack_state_get(void *data, u64 *val)
1562 {
1563         unsigned long flags;
1564         u32 mc_override;
1565
1566         spin_lock_irqsave(&emc_access_lock, flags);
1567         mc_override = mc_readl(MC_EMEM_ARB_OVERRIDE);
1568         spin_unlock_irqrestore(&emc_access_lock, flags);
1569
1570         *val = (mc_override & MC_EMEM_ARB_OVERRIDE_EACK_MASK);
1571         return 0;
1572 }
1573
1574 static int eack_state_set(void *data, u64 val)
1575 {
1576         tegra_emc_set_eack_state(val);
1577         return 0;
1578 }
1579 DEFINE_SIMPLE_ATTRIBUTE(eack_state_fops, eack_state_get,
1580                         eack_state_set, "%llu\n");
1581
1582 static int efficiency_get(void *data, u64 *val)
1583 {
1584         *val = tegra_emc_bw_efficiency;
1585         return 0;
1586 }
1587 static int efficiency_set(void *data, u64 val)
1588 {
1589         tegra_emc_bw_efficiency = (val > 100) ? 100 : val;
1590         if (emc)
1591                 tegra_clk_shared_bus_update(emc);
1592
1593         return 0;
1594 }
1595 DEFINE_SIMPLE_ATTRIBUTE(efficiency_fops, efficiency_get,
1596                         efficiency_set, "%llu\n");
1597
1598 static int efficiency_boost_get(void *data, u64 *val)
1599 {
1600         *val = tegra_emc_bw_efficiency_boost;
1601         return 0;
1602 }
1603 static int efficiency_boost_set(void *data, u64 val)
1604 {
1605         tegra_emc_bw_efficiency_boost = (val > 100) ? 100 : val;
1606         if (emc)
1607                 tegra_clk_shared_bus_update(emc);
1608
1609         return 0;
1610 }
1611 DEFINE_SIMPLE_ATTRIBUTE(efficiency_boost_fops, efficiency_boost_get,
1612                         efficiency_boost_set, "%llu\n");
1613
1614 static int __init tegra_emc_debug_init(void)
1615 {
1616         if (!tegra_emc_table)
1617                 return 0;
1618
1619         emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL);
1620         if (!emc_debugfs_root)
1621                 return -ENOMEM;
1622
1623         if (!debugfs_create_file(
1624                 "stats", S_IRUGO, emc_debugfs_root, NULL, &emc_stats_fops))
1625                 goto err_out;
1626
1627         if (!debugfs_create_file("dram_temperature", S_IRUGO, emc_debugfs_root,
1628                                  NULL, &dram_temperature_fops))
1629                 goto err_out;
1630
1631         if (!debugfs_create_file("over_temp_state", S_IRUGO | S_IWUSR,
1632                                  emc_debugfs_root, NULL, &over_temp_state_fops))
1633                 goto err_out;
1634
1635         if (!debugfs_create_file(
1636                 "eack_state", S_IRUGO | S_IWUSR, emc_debugfs_root, NULL, &eack_state_fops))
1637                 goto err_out;
1638
1639         if (!debugfs_create_file("efficiency", S_IRUGO | S_IWUSR,
1640                                  emc_debugfs_root, NULL, &efficiency_fops))
1641                 goto err_out;
1642
1643         if (!debugfs_create_file("efficiency_boost", S_IRUGO | S_IWUSR,
1644                                  emc_debugfs_root, NULL, &efficiency_boost_fops))
1645                 goto err_out;
1646
1647         return 0;
1648
1649 err_out:
1650         debugfs_remove_recursive(emc_debugfs_root);
1651         return -ENOMEM;
1652 }
1653
1654 late_initcall(tegra_emc_debug_init);
1655 #endif