ARM: tegra: emc: Derating support
[linux-3.10.git] / arch / arm / mach-tegra / tegra14_emc.c
1 /*
2  * arch/arm/mach-tegra/tegra14_emc.c
3  *
4  * Copyright (c) 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 version 2 as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
18  *
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/clk.h>
23 #include <linux/err.h>
24 #include <linux/io.h>
25 #include <linux/module.h>
26 #include <linux/delay.h>
27 #include <linux/platform_device.h>
28 #include <linux/platform_data/tegra_emc.h>
29 #include <linux/debugfs.h>
30 #include <linux/seq_file.h>
31 #include <linux/hrtimer.h>
32 #include <linux/pasr.h>
33
34 #include <asm/cputime.h>
35
36 #include "clock.h"
37 #include "dvfs.h"
38 #include "board.h"
39 #include "iomap.h"
40 #include "tegra14_emc.h"
41
42 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
43 static bool emc_enable = true;
44 #else
45 static bool emc_enable;
46 #endif
47 module_param(emc_enable, bool, 0644);
48
49 u8 tegra_emc_bw_efficiency = 100;
50 static struct emc_iso_usage tegra14_emc_iso_usage[] = {
51         { BIT(EMC_USER_DC1),                            80 },
52         { BIT(EMC_USER_DC2),                            80 },
53         { BIT(EMC_USER_DC1) | BIT(EMC_USER_DC2),        50 },
54         { BIT(EMC_USER_DC1) | BIT(EMC_USER_VI),         50 },
55         { BIT(EMC_USER_DC2) | BIT(EMC_USER_VI),         50 },
56         { BIT(EMC_USER_BB),     50 },
57 };
58
59 #define PLL_C_DIRECT_FLOOR              333500000
60 #define EMC_STATUS_UPDATE_TIMEOUT       100
61 #define TEGRA_EMC_TABLE_MAX_SIZE        16
62
63 #define TEGRA_EMC_MODE_REG_17   0x00110000
64 #define TEGRA_EMC_MRW_DEV_SHIFT 30
65 #define TEGRA_EMC_MRW_DEV1      2
66 #define TEGRA_EMC_MRW_DEV2      1
67
68 #define TEGRA_MC_EMEM_ADR_CFG_DEV       0x58
69 #define TEGRA_EMEM_DEV_DEVSIZE_SHIFT    16
70 #define TEGRA_EMEM_DEV_DEVSIZE_MASK     0xF
71
72 enum {
73         DLL_CHANGE_NONE = 0,
74         DLL_CHANGE_ON,
75         DLL_CHANGE_OFF,
76 };
77
78 #define CLK_RST_CONTROLLER_CLK_SOURCE_EMC       0x19c
79 #define EMC_CLK_DIV_SHIFT               0
80 #define EMC_CLK_DIV_MASK                (0xFF << EMC_CLK_DIV_SHIFT)
81 #define EMC_CLK_SOURCE_SHIFT            29
82 #define EMC_CLK_SOURCE_MASK             (0x7 << EMC_CLK_SOURCE_SHIFT)
83 #define EMC_CLK_LOW_JITTER_ENABLE       (0x1 << 31)
84 #define EMC_CLK_FORCE_CC_TRIGGER        (0x1 << 27)
85 #define EMC_CLK_MC_SAME_FREQ            (0x1 << 16)
86
87 #define PMC_IO_DPD2_REQ                 0x1C0
88 #define PMC_IO_DPD2_REQ_CODE_SHIFT      30
89 #define PMC_IO_DPD2_REQ_CODE_DPD_OFF    0x1
90 #define PMC_IO_DPD2_REQ_CODE_DPD_ON     0x2
91 #define PMC_IO_DPD2_REQ_DISC_BIAS       (0x1 << 27)
92
93 /* FIXME: actual Tegar14 list */
94 #define BURST_REG_LIST \
95         DEFINE_REG(TEGRA_EMC_BASE, EMC_RC),                     \
96         DEFINE_REG(TEGRA_EMC_BASE, EMC_RFC),                    \
97         DEFINE_REG(TEGRA_EMC_BASE, EMC_RFC_SLR),                \
98         DEFINE_REG(TEGRA_EMC_BASE, EMC_RAS),                    \
99         DEFINE_REG(TEGRA_EMC_BASE, EMC_RP),                     \
100         DEFINE_REG(TEGRA_EMC_BASE, EMC_R2W),                    \
101         DEFINE_REG(TEGRA_EMC_BASE, EMC_W2R),                    \
102         DEFINE_REG(TEGRA_EMC_BASE, EMC_R2P),                    \
103         DEFINE_REG(TEGRA_EMC_BASE, EMC_W2P),                    \
104         DEFINE_REG(TEGRA_EMC_BASE, EMC_RD_RCD),                 \
105         DEFINE_REG(TEGRA_EMC_BASE, EMC_WR_RCD),                 \
106         DEFINE_REG(TEGRA_EMC_BASE, EMC_RRD),                    \
107         DEFINE_REG(TEGRA_EMC_BASE, EMC_REXT),                   \
108         DEFINE_REG(TEGRA_EMC_BASE, EMC_WEXT),                   \
109         DEFINE_REG(TEGRA_EMC_BASE, EMC_WDV),                    \
110         DEFINE_REG(TEGRA_EMC_BASE, EMC_WDV_MASK),               \
111         DEFINE_REG(TEGRA_EMC_BASE, EMC_QUSE_WIDTH),             \
112         DEFINE_REG(TEGRA_EMC_BASE, EMC_IBDLY),                  \
113         DEFINE_REG(TEGRA_EMC_BASE, EMC_PUTERM),                 \
114         DEFINE_REG(TEGRA_EMC_BASE, EMC_PUTERM_WIDTH),           \
115         DEFINE_REG(TEGRA_EMC_BASE, EMC_CDB_CNTL_2),             \
116         DEFINE_REG(TEGRA_EMC_BASE, EMC_QRST),                   \
117         DEFINE_REG(TEGRA_EMC_BASE, EMC_RDV_MASK),               \
118         DEFINE_REG(TEGRA_EMC_BASE, EMC_REFRESH),                \
119         DEFINE_REG(TEGRA_EMC_BASE, EMC_BURST_REFRESH_NUM),      \
120         DEFINE_REG(TEGRA_EMC_BASE, EMC_PRE_REFRESH_REQ_CNT),    \
121         DEFINE_REG(TEGRA_EMC_BASE, EMC_PDEX2WR),                \
122         DEFINE_REG(TEGRA_EMC_BASE, EMC_PDEX2RD),                \
123         DEFINE_REG(TEGRA_EMC_BASE, EMC_PCHG2PDEN),              \
124         DEFINE_REG(TEGRA_EMC_BASE, EMC_ACT2PDEN),               \
125         DEFINE_REG(TEGRA_EMC_BASE, EMC_AR2PDEN),                \
126         DEFINE_REG(TEGRA_EMC_BASE, EMC_RW2PDEN),                \
127         DEFINE_REG(TEGRA_EMC_BASE, EMC_TXSR),                   \
128         DEFINE_REG(TEGRA_EMC_BASE, EMC_TXSRDLL),                \
129         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCKE),                   \
130         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCKESR),                 \
131         DEFINE_REG(TEGRA_EMC_BASE, EMC_TPD),                    \
132         DEFINE_REG(TEGRA_EMC_BASE, EMC_TFAW),                   \
133         DEFINE_REG(TEGRA_EMC_BASE, EMC_TRPAB),                  \
134         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCLKSTABLE),             \
135         DEFINE_REG(TEGRA_EMC_BASE, EMC_TCLKSTOP),               \
136         DEFINE_REG(TEGRA_EMC_BASE, EMC_TREFBW),                 \
137         DEFINE_REG(TEGRA_EMC_BASE, EMC_ODT_WRITE),              \
138         DEFINE_REG(TEGRA_EMC_BASE, EMC_ODT_READ),               \
139         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_CFG5),              \
140         DEFINE_REG(TEGRA_EMC_BASE, EMC_CFG_DIG_DLL_PERIOD),     \
141         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS0),         \
142         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS1),         \
143         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS2),         \
144         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS3),         \
145         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS4),         \
146         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS5),         \
147         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS6),         \
148         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQS7),         \
149         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE0),        \
150         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE1),        \
151         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE2),        \
152         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE3),        \
153         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE4),        \
154         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE5),        \
155         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE6),        \
156         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_QUSE7),        \
157         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_ADDR0),        \
158         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_ADDR1),        \
159         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_ADDR2),        \
160         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS0),        \
161         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS1),        \
162         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS2),        \
163         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS3),        \
164         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS4),        \
165         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS5),        \
166         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS6),        \
167         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLI_TRIM_TXDQS7),        \
168         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ0),          \
169         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ1),          \
170         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ2),          \
171         DEFINE_REG(TEGRA_EMC_BASE, EMC_DLL_XFORM_DQ3),          \
172         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2CMDPADCTRL),          \
173         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2CMDPADCTRL4),         \
174         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQSPADCTRL2),         \
175         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQPADCTRL2),          \
176         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2CLKPADCTRL),          \
177         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2CLKPADCTRL2),         \
178         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2COMPPADCTRL),         \
179         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2VTTGENPADCTRL),       \
180         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQSPADCTRL3),         \
181         DEFINE_REG(TEGRA_EMC_BASE, EMC_XM2DQSPADCTRL4),         \
182         DEFINE_REG(TEGRA_EMC_BASE, EMC_DSR_VTTGEN_DRV),         \
183         DEFINE_REG(TEGRA_EMC_BASE, EMC_TXDSRVTTGEN),            \
184         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_SPARE),             \
185         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT_TERM_CTRL),          \
186         DEFINE_REG(TEGRA_EMC_BASE, EMC_ZCAL_INTERVAL),          \
187         DEFINE_REG(TEGRA_EMC_BASE, EMC_ZCAL_WAIT_CNT),          \
188         DEFINE_REG(TEGRA_EMC_BASE, EMC_MRS_WAIT_CNT),           \
189         DEFINE_REG(TEGRA_EMC_BASE, EMC_MRS_WAIT_CNT2),          \
190         DEFINE_REG(TEGRA_EMC_BASE, EMC_AUTO_CAL_CONFIG2),       \
191         DEFINE_REG(TEGRA_EMC_BASE, EMC_AUTO_CAL_CONFIG3),       \
192         DEFINE_REG(TEGRA_EMC_BASE, EMC_AUTO_CAL_CONFIG),        \
193         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT),                    \
194         DEFINE_REG(TEGRA_EMC_BASE, EMC_CTT_DURATION),           \
195         DEFINE_REG(TEGRA_EMC_BASE, EMC_DYN_SELF_REF_CONTROL),   \
196         DEFINE_REG(TEGRA_EMC_BASE, EMC_QUSE),                   \
197         DEFINE_REG(TEGRA_EMC_BASE, EMC_EINPUT),                 \
198         DEFINE_REG(TEGRA_EMC_BASE, EMC_EINPUT_DURATION),        \
199         DEFINE_REG(TEGRA_EMC_BASE, EMC_QSAFE),                  \
200         DEFINE_REG(TEGRA_EMC_BASE, EMC_RDV),                    \
201         DEFINE_REG(TEGRA_EMC_BASE, EMC_FBIO_CFG6),              \
202         DEFINE_REG(TEGRA_EMC_BASE, EMC_PIPE_MACRO_CTL),         \
203         DEFINE_REG(TEGRA_EMC_BASE, EMC_QPOP),                   \
204         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_CFG),             \
205         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_OUTSTANDING_REQ), \
206         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_OUTSTANDING_REQ_RING3),   \
207         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RCD),      \
208         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RP),       \
209         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RC),       \
210         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RAS),      \
211         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_FAW),      \
212         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RRD),      \
213         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_RAP2PRE),  \
214         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_WAP2PRE),  \
215         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_R2R),      \
216         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_W2W),      \
217         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_R2W),      \
218         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_TIMING_W2R),      \
219         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_DA_TURNS),        \
220         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_DA_COVERS),       \
221         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_MISC0),           \
222         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_RING1_THROTTLE),  \
223         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_RING3_THROTTLE),  \
224
225 #define BURST_UP_DOWN_REG_LIST \
226         DEFINE_REG(TEGRA_MC_BASE, MC_PTSA_GRANT_DECREMENT),     \
227         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_G2_0),   \
228         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_G2_1),   \
229         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_NV_0),   \
230         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_NV2_0),  \
231         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_NV_1),   \
232         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_NV2_1),  \
233         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_EPP_0),  \
234         DEFINE_REG(TEGRA_MC_BASE, MC_LATENCY_ALLOWANCE_EPP_1),
235
236 #define DEFINE_REG(base, reg) ((base) ? (IO_ADDRESS((base)) + (reg)) : 0)
237 static void __iomem *burst_reg_addr[TEGRA14_EMC_MAX_NUM_REGS] = {
238         BURST_REG_LIST
239 };
240 #ifndef EMULATE_CLOCK_SWITCH
241 static void __iomem *burst_up_down_reg_addr[TEGRA14_EMC_MAX_NUM_REGS] = {
242         BURST_UP_DOWN_REG_LIST
243 };
244 #endif
245 #undef DEFINE_REG
246
247 #define DEFINE_REG(base, reg)   reg##_INDEX
248 enum {
249         BURST_REG_LIST
250 };
251 #undef DEFINE_REG
252
253 #define CLK_RST_CONTROLLER_CLK_OUT_ENB_X_SET    0x284
254 #define CLK_RST_CONTROLLER_CLK_OUT_ENB_X_CLR    0x288
255 #define CLK_ENB_EMC_DLL                         (1 << 14)
256 #define CLK_RST_CONTROLLER_CLK_SOURCE_EMC_DLL   0x664
257 #define EMC_DLL_DYN_MUX_CTRL                    (1 << 16)
258
259 #define FBIO_SPARE_CFG_SW_DLL_RST_CTRL_N        (1 << 27)
260
261 struct emc_sel {
262         struct clk      *input;
263         u32             value;
264         unsigned long   input_rate;
265 };
266 static struct emc_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
267 static struct tegra14_emc_table start_timing;
268 static const struct tegra14_emc_table *emc_timing;
269 static unsigned long dram_over_temp_state = DRAM_OVER_TEMP_NONE;
270
271 static ktime_t clkchange_time;
272 static int clkchange_delay = 100;
273
274 static const struct tegra14_emc_table *tegra_emc_table;
275 static const struct tegra14_emc_table *tegra_emc_table_derated;
276 static int tegra_emc_table_size;
277
278 static u32 dram_dev_num;
279 static u32 dram_type = -1;
280
281 static u32 dsr_override;
282
283 static int pasr_enable;
284
285 static struct clk *emc;
286
287 static struct {
288         cputime64_t time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE];
289         int last_sel;
290         u64 last_update;
291         u64 clkchange_count;
292         spinlock_t spinlock;
293 } emc_stats;
294
295 static DEFINE_SPINLOCK(emc_access_lock);
296
297 static void __iomem *emc_base = IO_ADDRESS(TEGRA_EMC_BASE);
298 /* !!!FIXME!!! Need clean up for T148 */
299 #ifdef CONFIG_ARCH_TEGRA_11x_SOC
300 static void __iomem *emc0_base = IO_ADDRESS(TEGRA_EMC0_BASE);
301 static void __iomem *emc1_base = IO_ADDRESS(TEGRA_EMC1_BASE);
302 #endif
303 static void __iomem *mc_base = IO_ADDRESS(TEGRA_MC_BASE);
304 static void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
305 static void __iomem *pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
306
307 static inline void emc_writel(u32 val, unsigned long addr)
308 {
309         writel(val, emc_base + addr);
310 }
311 /* !!!FIXME!!! Need clean up for T148 */
312 #ifdef CONFIG_ARCH_TEGRA_11x_SOC
313 static inline void emc0_writel(u32 val, unsigned long addr)
314 {
315         writel(val, emc0_base + addr);
316 }
317 static inline void emc1_writel(u32 val, unsigned long addr)
318 {
319         writel(val, emc1_base + addr);
320 }
321 #endif
322 static inline u32 emc_readl(unsigned long addr)
323 {
324         return readl(emc_base + addr);
325 }
326 static inline void mc_writel(u32 val, unsigned long addr)
327 {
328         writel(val, mc_base + addr);
329 }
330 static inline u32 mc_readl(unsigned long addr)
331 {
332         return readl(mc_base + addr);
333 }
334
335 static inline void ccfifo_writel(u32 val, unsigned long addr)
336 {
337         writel(val, emc_base + EMC_CCFIFO_DATA);
338         writel(addr, emc_base + EMC_CCFIFO_ADDR);
339 }
340
341 static int last_round_idx;
342 static inline int get_start_idx(unsigned long rate)
343 {
344         if (tegra_emc_table[last_round_idx].rate == rate)
345                 return last_round_idx;
346         return 0;
347 }
348
349 static void emc_last_stats_update(int last_sel)
350 {
351         unsigned long flags;
352         u64 cur_jiffies = get_jiffies_64();
353
354         spin_lock_irqsave(&emc_stats.spinlock, flags);
355
356         if (emc_stats.last_sel < TEGRA_EMC_TABLE_MAX_SIZE)
357                 emc_stats.time_at_clock[emc_stats.last_sel] =
358                         emc_stats.time_at_clock[emc_stats.last_sel] +
359                         (cur_jiffies - emc_stats.last_update);
360
361         emc_stats.last_update = cur_jiffies;
362
363         if (last_sel < TEGRA_EMC_TABLE_MAX_SIZE) {
364                 emc_stats.clkchange_count++;
365                 emc_stats.last_sel = last_sel;
366         }
367         spin_unlock_irqrestore(&emc_stats.spinlock, flags);
368 }
369
370 static int wait_for_update(u32 status_reg, u32 bit_mask, bool updated_state)
371 {
372         int i;
373         for (i = 0; i < EMC_STATUS_UPDATE_TIMEOUT; i++) {
374                 if (!!(emc_readl(status_reg) & bit_mask) == updated_state)
375                         return 0;
376                 udelay(1);
377         }
378         return -ETIMEDOUT;
379 }
380
381 static inline void emc_timing_update(void)
382 {
383         int err;
384
385         emc_writel(0x1, EMC_TIMING_CONTROL);
386         err = wait_for_update(EMC_STATUS,
387                               EMC_STATUS_TIMING_UPDATE_STALLED, false);
388         if (err) {
389                 pr_err("%s: timing update error: %d", __func__, err);
390                 BUG();
391         }
392 }
393
394 static inline void auto_cal_disable(void)
395 {
396         int err;
397
398         emc_writel(0, EMC_AUTO_CAL_INTERVAL);
399         err = wait_for_update(EMC_AUTO_CAL_STATUS,
400                               EMC_AUTO_CAL_STATUS_ACTIVE, false);
401         if (err) {
402                 pr_err("%s: disable auto-cal error: %d", __func__, err);
403                 BUG();
404         }
405 }
406
407 static inline void set_over_temp_timing(
408         const struct tegra14_emc_table *next_timing, unsigned long state)
409 {
410 #define REFRESH_X2      1
411 #define REFRESH_X4      2
412 #define REFRESH_SPEEDUP(val, speedup)                           \
413         do {                                                    \
414                 val = ((val) & 0xFFFF0000) |                    \
415                         (((val) & 0xFFFF) >> (speedup));        \
416         } while (0)
417
418         u32 ref = next_timing->burst_regs[EMC_REFRESH_INDEX];
419         u32 pre_ref = next_timing->burst_regs[EMC_PRE_REFRESH_REQ_CNT_INDEX];
420         u32 dsr_cntrl = next_timing->burst_regs[EMC_DYN_SELF_REF_CONTROL_INDEX];
421
422         switch (state) {
423         case DRAM_OVER_TEMP_NONE:
424                 break;
425         case DRAM_OVER_TEMP_REFRESH_X2:
426                 REFRESH_SPEEDUP(ref, REFRESH_X2);
427                 REFRESH_SPEEDUP(pre_ref, REFRESH_X2);
428                 REFRESH_SPEEDUP(dsr_cntrl, REFRESH_X2);
429                 break;
430         case DRAM_OVER_TEMP_REFRESH_X4:
431         case DRAM_OVER_TEMP_THROTTLE:
432                 REFRESH_SPEEDUP(ref, REFRESH_X4);
433                 REFRESH_SPEEDUP(pre_ref, REFRESH_X4);
434                 REFRESH_SPEEDUP(dsr_cntrl, REFRESH_X4);
435                 break;
436         default:
437                 WARN(1, "%s: Failed to set dram over temp state %lu\n",
438                      __func__, state);
439                 return;
440         }
441
442         __raw_writel(ref, burst_reg_addr[EMC_REFRESH_INDEX]);
443         __raw_writel(pre_ref, burst_reg_addr[EMC_PRE_REFRESH_REQ_CNT_INDEX]);
444         __raw_writel(dsr_cntrl, burst_reg_addr[EMC_DYN_SELF_REF_CONTROL_INDEX]);
445 }
446
447 static inline bool dqs_preset(const struct tegra14_emc_table *next_timing,
448                               const struct tegra14_emc_table *last_timing)
449 {
450         bool ret = false;
451
452 #define DQS_SET(reg, bit)                                               \
453         do {                                                            \
454                 if ((next_timing->burst_regs[EMC_##reg##_INDEX] &       \
455                      EMC_##reg##_##bit##_ENABLE) &&                     \
456                     (!(last_timing->burst_regs[EMC_##reg##_INDEX] &     \
457                        EMC_##reg##_##bit##_ENABLE)))   {                \
458                         emc_writel(last_timing->burst_regs[EMC_##reg##_INDEX] \
459                                    | EMC_##reg##_##bit##_ENABLE, EMC_##reg); \
460                         ret = true;                                     \
461                 }                                                       \
462         } while (0)
463
464         DQS_SET(XM2DQSPADCTRL2, RX_FT_REC);
465         DQS_SET(XM2DQSPADCTRL2, VREF_DQ);
466
467         return ret;
468 }
469
470 static inline int get_dll_change(const struct tegra14_emc_table *next_timing,
471                                  const struct tegra14_emc_table *last_timing)
472 {
473         bool next_dll_enabled = !(next_timing->emc_mode_1 & 0x1);
474         bool last_dll_enabled = !(last_timing->emc_mode_1 & 0x1);
475
476         if (next_dll_enabled == last_dll_enabled)
477                 return DLL_CHANGE_NONE;
478         else if (next_dll_enabled)
479                 return DLL_CHANGE_ON;
480         else
481                 return DLL_CHANGE_OFF;
482 }
483
484 static inline void set_dram_mode(const struct tegra14_emc_table *next_timing,
485                                  const struct tegra14_emc_table *last_timing,
486                                  int dll_change)
487 {
488         /* first mode_2, then mode_1; mode_reset is not applicable */
489         if (next_timing->emc_mode_2 != last_timing->emc_mode_2)
490                 ccfifo_writel(next_timing->emc_mode_2, EMC_MRW2);
491         if (next_timing->emc_mode_1 != last_timing->emc_mode_1)
492                 ccfifo_writel(next_timing->emc_mode_1, EMC_MRW);
493         if (next_timing->emc_mode_4 != last_timing->emc_mode_4)
494                 ccfifo_writel(next_timing->emc_mode_4, EMC_MRW4);
495 }
496
497 static inline void do_clock_change(u32 clk_setting)
498 {
499         int err;
500
501         mc_readl(MC_EMEM_ADR_CFG);      /* completes prev writes */
502         writel(clk_setting, clk_base + emc->reg);
503         readl(clk_base + emc->reg);/* completes prev write */
504
505         err = wait_for_update(EMC_INTSTATUS,
506                               EMC_INTSTATUS_CLKCHANGE_COMPLETE, true);
507         if (err) {
508                 pr_err("%s: clock change completion error: %d", __func__, err);
509                 BUG();
510         }
511 }
512
513 static u32 emc_prelock_dll(const struct tegra14_emc_table *last_timing,
514                            const struct tegra14_emc_table *next_timing)
515 {
516         u32 dll_locked, dll_out;
517         u32 emc_cfg_dig_dll;
518         u32 emc_dll_clk_src;
519         u32 fbio_spare_old, fbio_spare_new;
520         u32 div_value = (next_timing->src_sel_reg & EMC_CLK_DIV_MASK);
521         u32 src_value = (next_timing->src_sel_reg & EMC_CLK_SOURCE_MASK);
522
523         /* WAR for missing PLLC_UD DLL clock source selector. */
524         if (src_value == (0x7 << EMC_CLK_SOURCE_SHIFT))
525                 src_value = (0x1 << EMC_CLK_SOURCE_SHIFT);
526
527         /*
528          * Step 1:
529          *   If the DLL is disabled don't bother disabling it again.
530          */
531         emc_cfg_dig_dll = emc_readl(EMC_CFG_DIG_DLL);
532
533         if (last_timing->rate <= 408000)
534                 goto skip_dll_disable;
535
536         emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_EN;
537         emc_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
538         emc_timing_update();
539
540 skip_dll_disable:
541         /*
542          * Step 1.25:
543          *   Force the DLL into override mode.
544          */
545         dll_out = emc_readl(EMC_DIG_DLL_STATUS) & EMC_DIG_DLL_STATUS_OUT;
546         emc_cfg_dig_dll = emc_readl(EMC_CFG_DIG_DLL);
547         emc_cfg_dig_dll &= ~(EMC_CFG_DIG_DLL_OVERRIDE_VAL_MASK <<
548                              EMC_CFG_DIG_DLL_OVERRIDE_VAL_SHIFT);
549         emc_cfg_dig_dll |= ((dll_out & EMC_CFG_DIG_DLL_OVERRIDE_VAL_MASK) <<
550                             EMC_CFG_DIG_DLL_OVERRIDE_VAL_SHIFT);
551         emc_cfg_dig_dll |= EMC_CFG_DIG_DLL_OVERRIDE_EN;
552         emc_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
553         emc_timing_update();
554
555         /*
556          * Step 1.5:
557          *   Force the DLL into one shot mode.
558          */
559         emc_cfg_dig_dll = emc_readl(EMC_CFG_DIG_DLL);
560         emc_cfg_dig_dll &= ~(EMC_CFG_DIG_DLL_MODE_MASK <<
561                              EMC_CFG_DIG_DLL_MODE_SHIFT);
562         emc_cfg_dig_dll |= (EMC_CFG_DIG_DLL_MODE_RUN_TIL_LOCK <<
563                             EMC_CFG_DIG_DLL_MODE_SHIFT);
564         emc_cfg_dig_dll &= ~(EMC_CFG_DIG_DLL_UDSET_MASK <<
565                              EMC_CFG_DIG_DLL_UDSET_SHIFT);
566         emc_cfg_dig_dll |= (0x2 << EMC_CFG_DIG_DLL_UDSET_SHIFT);
567         emc_cfg_dig_dll &= ~(EMC_CFG_DIG_DLL_LOCK_LIMIT_MASK <<
568                              EMC_CFG_DIG_DLL_LOCK_LIMIT_SHIFT);
569         emc_cfg_dig_dll |= (next_timing->emc_cfg_dig_dll &
570                             (3 << EMC_CFG_DIG_DLL_LOCK_LIMIT_SHIFT));
571         emc_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
572         emc_timing_update();
573
574         /*
575          * Step 2:
576          *   Set the DLL's prelocking input. We do this so that we can get an
577          * override value for when we do the actual swap to this PLL later on.
578          * Once we swap, we will want this override value.
579          */
580         emc_dll_clk_src = (div_value | src_value);
581         writel(emc_dll_clk_src,
582                clk_base + CLK_RST_CONTROLLER_CLK_SOURCE_EMC_DLL);
583         writel(emc_dll_clk_src | EMC_DLL_DYN_MUX_CTRL,
584                clk_base + CLK_RST_CONTROLLER_CLK_SOURCE_EMC_DLL);
585
586         /*
587          * Step 2.5:
588          *   Enable CLK to DLL from CAR.
589          */
590         writel(CLK_ENB_EMC_DLL,
591                clk_base + CLK_RST_CONTROLLER_CLK_OUT_ENB_X_SET);
592         udelay(1);
593
594         /*
595          * Step 3:
596          *   Reset the DLL and wait for it to lock against the target freq.
597          */
598         fbio_spare_old = emc_readl(EMC_FBIO_SPARE);
599         fbio_spare_new = fbio_spare_old | FBIO_SPARE_CFG_SW_DLL_RST_CTRL_N;
600
601         emc_writel(fbio_spare_new, EMC_FBIO_SPARE);
602         emc_timing_update();
603         emc_writel(fbio_spare_old, EMC_FBIO_SPARE);
604         emc_timing_update();
605
606         emc_cfg_dig_dll = emc_readl(EMC_CFG_DIG_DLL);
607         emc_cfg_dig_dll |= (EMC_CFG_DIG_DLL_EN);
608         emc_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
609         emc_timing_update();
610         udelay(1);
611
612         do {
613                 dll_locked = emc_readl(EMC_DIG_DLL_STATUS) &
614                         EMC_DIG_DLL_STATUS_LOCKED;
615         } while (!dll_locked);
616
617         if (WARN_ON((emc_readl(EMC_INTSTATUS) &
618                      EMC_INTSTATUS_DLL_LOCK_TIMEOUT_INT)))
619                 emc_writel(EMC_INTSTATUS_DLL_LOCK_TIMEOUT_INT,
620                            EMC_INTSTATUS);
621
622         /*
623          * Step 4:
624          *   Disable CLK to DLL from CAR.
625          */
626         writel(CLK_ENB_EMC_DLL,
627                clk_base + CLK_RST_CONTROLLER_CLK_OUT_ENB_X_CLR);
628         udelay(1);
629
630         /*
631          * Step 5:
632          *   Now, reinvoke the state machine logic without the clock.
633          */
634         emc_cfg_dig_dll = emc_readl(EMC_CFG_DIG_DLL);
635         emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_EN;
636         emc_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
637         emc_timing_update();
638
639         emc_cfg_dig_dll |= EMC_CFG_DIG_DLL_EN;
640         emc_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
641         emc_timing_update();
642         udelay(1);
643
644         dll_out = emc_readl(EMC_DIG_DLL_STATUS) & EMC_DIG_DLL_STATUS_OUT;
645
646         emc_cfg_dig_dll = emc_readl(EMC_CFG_DIG_DLL);
647         emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_EN;
648         emc_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
649         emc_timing_update();
650
651         return dll_out;
652 }
653
654 static noinline void emc_set_clock(const struct tegra14_emc_table *next_timing,
655                                    const struct tegra14_emc_table *last_timing,
656                                    u32 clk_setting)
657 {
658         int i, dll_change, pre_wait;
659         bool dyn_sref_enabled, zcal_long;
660
661         u32 dll_override, emc_cfg_dig_dll, pmc_dpd;
662         u32 t_start, t_diff;
663
664         u32 use_prelock = 0;
665         u32 emc_cfg_reg = emc_readl(EMC_CFG);
666
667         if (!(clk_setting & EMC_CLK_FORCE_CC_TRIGGER))
668                 use_prelock = next_timing->emc_cfg_dig_dll & EMC_CFG_DIG_DLL_EN;
669
670         dyn_sref_enabled = emc_cfg_reg & EMC_CFG_DYN_SREF_ENABLE;
671         dll_change = get_dll_change(next_timing, last_timing);
672         zcal_long = (next_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] != 0) &&
673                 (last_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] == 0);
674
675         /* 1. clear clkchange_complete interrupts */
676         emc_writel(EMC_INTSTATUS_CLKCHANGE_COMPLETE |
677                    EMC_INTSTATUS_DLL_LOCK_TIMEOUT_INT, EMC_INTSTATUS);
678
679         /* 1.5 On t148, prelock the DLL - assuming the DLL is enabled. */
680         if (use_prelock)
681                 dll_override = emc_prelock_dll(last_timing, next_timing);
682         else
683                 dll_override = 0;
684
685         /* 2. disable dynamic self-refresh and preset dqs vref, then wait for
686            possible self-refresh entry/exit and/or dqs vref settled - waiting
687            before the clock change decreases worst case change stall time */
688         pre_wait = 0;
689         if (dyn_sref_enabled) {
690                 emc_cfg_reg &= ~EMC_CFG_DYN_SREF_ENABLE;
691                 emc_writel(emc_cfg_reg, EMC_CFG);
692                 pre_wait = 5;           /* 5us+ for self-refresh entry/exit */
693         }
694
695         /* 2.5 check dq/dqs vref delay */
696         if (dqs_preset(next_timing, last_timing)) {
697                 if (pre_wait < 30)
698                         pre_wait = 30; /* (T148) 30us+ for dqs vref settled */
699                 /* Take the DISC pads out of DPD. */
700                 pmc_dpd = (PMC_IO_DPD2_REQ_CODE_DPD_OFF <<
701                            PMC_IO_DPD2_REQ_CODE_SHIFT);
702                 writel(pmc_dpd | PMC_IO_DPD2_REQ_DISC_BIAS,
703                        pmc_base + PMC_IO_DPD2_REQ);
704         }
705         emc_timing_update();
706         t_start = tegra_read_usec_raw();
707
708         /* 3. For t148, leave auto cal alone. */
709
710         /* 4. program burst shadow registers */
711         for (i = 0; i < next_timing->burst_regs_num; i++) {
712                 if (!burst_reg_addr[i])
713                         continue;
714                 __raw_writel(next_timing->burst_regs[i], burst_reg_addr[i]);
715         }
716         if (!use_prelock && !(clk_setting & EMC_CLK_FORCE_CC_TRIGGER))
717                 writel(next_timing->emc_cfg_dig_dll | EMC_CFG_DIG_DLL_RESET |
718                        EMC_CFG_DIG_DLL_OVERRIDE_EN, emc_base + EMC_CFG_DIG_DLL);
719
720         if ((dram_type == DRAM_TYPE_LPDDR2) &&
721             (dram_over_temp_state != DRAM_OVER_TEMP_NONE))
722                 set_over_temp_timing(next_timing, dram_over_temp_state);
723
724         emc_cfg_reg &= ~EMC_CFG_UPDATE_MASK;
725         emc_cfg_reg |= next_timing->emc_cfg & EMC_CFG_UPDATE_MASK;
726         emc_writel(emc_cfg_reg, EMC_CFG);
727         wmb();
728         barrier();
729
730         /* 4.1 On ddr3 when DLL is re-started predict MRS long wait count and
731            overwrite DFS table setting - No DDR3 on t148. */
732
733         /* 5.2 Moved to ccfifo - see 6.1. */
734
735         /* 6. turn Off dll and enter self-refresh on DDR3 - No DDR3. */
736
737         /* 6.1 Disable auto-refresh right before clock change. */
738         ccfifo_writel(EMC_REFCTRL_DISABLE_ALL(dram_dev_num), EMC_REFCTRL);
739
740         /* 6.2 Set EMC_SEL_DPD_CTRL based on next freq: disable DATA_DPD for
741            frequencies above 408 MHz. */
742         if (next_timing->rate > 408000)
743                 ccfifo_writel(emc_readl(EMC_SEL_DPD_CTRL) &
744                               ~EMC_SEL_DPD_CTRL_DATA_DPD_ENABLE,
745                               EMC_SEL_DPD_CTRL);
746         else
747                 ccfifo_writel(emc_readl(EMC_SEL_DPD_CTRL) |
748                               EMC_SEL_DPD_CTRL_DATA_DPD_ENABLE,
749                               EMC_SEL_DPD_CTRL);
750
751         /* 7. flow control marker 2 */
752         ccfifo_writel(1, EMC_STALL_THEN_EXE_AFTER_CLKCHANGE);
753
754         /* 7.05 Re-enable autorefresh with the CCFIFO. */
755         ccfifo_writel(EMC_REFCTRL_ENABLE_ALL(dram_dev_num), EMC_REFCTRL);
756
757         /* 7.1 Use the new override value. */
758         if (use_prelock) {
759                 emc_cfg_dig_dll = next_timing->emc_cfg_dig_dll &
760                         ~(EMC_CFG_DIG_DLL_OVERRIDE_VAL_MASK <<
761                           EMC_CFG_DIG_DLL_OVERRIDE_VAL_SHIFT);
762                 emc_cfg_dig_dll |= (dll_override <<
763                                     EMC_CFG_DIG_DLL_OVERRIDE_VAL_SHIFT);
764                 emc_cfg_dig_dll |= EMC_CFG_DIG_DLL_OVERRIDE_EN;
765                 emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_EN;
766                 emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_STALL_RW_UNTIL_LOCK;
767                 ccfifo_writel(emc_cfg_dig_dll, EMC_CFG_DIG_DLL);
768         }
769
770         /* 7.2 Force an emc timing update here. */
771         ccfifo_writel(1, EMC_TIMING_CONTROL);
772
773         /* 8. exit self-refresh on DDR3 - No DDR3 on t148. */
774
775         /* 9. set dram mode registers */
776         set_dram_mode(next_timing, last_timing, dll_change);
777
778         /* 9.5 Update two fields in EMC_CFG that are not shadowed. */
779         emc_cfg_reg &= ~(EMC_CFG_MAN_PRE_WR | EMC_CFG_MAN_PRE_RD);
780         emc_cfg_reg |= next_timing->emc_cfg &
781                        (EMC_CFG_MAN_PRE_WR | EMC_CFG_MAN_PRE_RD);
782         ccfifo_writel(emc_cfg_reg, EMC_CFG);
783
784         /* 10. issue zcal command if turning zcal On */
785         if (zcal_long) {
786                 ccfifo_writel(EMC_ZQ_CAL_LONG_CMD_DEV0, EMC_ZQ_CAL);
787                 if (dram_dev_num > 1)
788                         ccfifo_writel(EMC_ZQ_CAL_LONG_CMD_DEV1, EMC_ZQ_CAL);
789         }
790
791         /* 10.1 dummy write to RO register to remove stall after change */
792         ccfifo_writel(0, EMC_CCFIFO_STATUS);
793
794         /* 11.5 program burst_up_down registers if emc rate is going down */
795         if (next_timing->rate < last_timing->rate) {
796                 for (i = 0; i < next_timing->burst_up_down_regs_num; i++)
797                         __raw_writel(next_timing->burst_up_down_regs[i],
798                                 burst_up_down_reg_addr[i]);
799                 wmb();
800         }
801
802         /* 11.75 Wait what ever time is necessary to make sure pre_wait us
803            have elapsed since programming vref mode. */
804         if (pre_wait) {
805                 t_diff = tegra_read_usec_raw() - t_start;
806                 if (t_diff <= pre_wait)
807                         udelay(1 + pre_wait - t_diff);
808         }
809
810         /* 12-14. read any MC register to ensure the programming is done
811            change EMC clock source register wait for clk change completion */
812         do_clock_change(clk_setting);
813
814         /* 14.1 re-enable auto-refresh */
815
816         /* 14.2 program burst_up_down registers if emc rate is going up */
817         if (next_timing->rate > last_timing->rate) {
818                 for (i = 0; i < next_timing->burst_up_down_regs_num; i++)
819                         __raw_writel(next_timing->burst_up_down_regs[i],
820                                 burst_up_down_reg_addr[i]);
821                 wmb();
822         }
823
824         /* 14.3 Check if we are entering schmit mode. If we are, then DPD can
825            be requested for the BG BIAS cells of the DISC pads. */
826         if (~next_timing->burst_regs[EMC_XM2DQSPADCTRL2_INDEX] &
827             EMC_XM2DQSPADCTRL2_RX_FT_REC_ENABLE) {
828                 pmc_dpd = (PMC_IO_DPD2_REQ_CODE_DPD_ON <<
829                            PMC_IO_DPD2_REQ_CODE_SHIFT);
830                 writel(pmc_dpd | PMC_IO_DPD2_REQ_DISC_BIAS,
831                        pmc_base + PMC_IO_DPD2_REQ);
832         }
833
834         /* 15. restore auto-cal. On t148, this is just a reprogramming - its
835            already enabled during the clock change itself. */
836         emc_writel(next_timing->emc_acal_interval, EMC_AUTO_CAL_INTERVAL);
837
838         /* 16. restore dynamic self-refresh - for t148 if requested, we will
839            leave DSR disabled. Otherwise just follow the table entry. */
840         if (!dsr_override && next_timing->emc_cfg & EMC_CFG_DYN_SREF_ENABLE) {
841                 emc_cfg_reg |= EMC_CFG_DYN_SREF_ENABLE;
842                 emc_writel(emc_cfg_reg, EMC_CFG);
843         }
844
845         /* 17. set zcal wait count */
846         if (zcal_long)
847                 emc_writel(next_timing->emc_zcal_cnt_long, EMC_ZCAL_WAIT_CNT);
848
849         /* 18. update restored timing */
850         emc_timing_update();
851 }
852
853 static inline void emc_get_timing(struct tegra14_emc_table *timing)
854 {
855         int i;
856
857         /* Burst updates depends on previous state; burst_up_down are
858          * stateless. */
859         for (i = 0; i < timing->burst_regs_num; i++) {
860                 if (burst_reg_addr[i])
861                         timing->burst_regs[i] = __raw_readl(burst_reg_addr[i]);
862                 else
863                         timing->burst_regs[i] = 0;
864         }
865         timing->emc_acal_interval = 0;
866         timing->emc_zcal_cnt_long = 0;
867         timing->emc_mode_reset = 0;
868         timing->emc_mode_1 = 0;
869         timing->emc_mode_2 = 0;
870         timing->emc_mode_4 = 0;
871         timing->emc_cfg = emc_readl(EMC_CFG);
872         timing->rate = clk_get_rate_locked(emc) / 1000;
873 }
874
875 /* The EMC registers have shadow registers. When the EMC clock is updated
876  * in the clock controller, the shadow registers are copied to the active
877  * registers, allowing glitchless memory bus frequency changes.
878  * This function updates the shadow registers for a new clock frequency,
879  * and relies on the clock lock on the emc clock to avoid races between
880  * multiple frequency changes. In addition access lock prevents concurrent
881  * access to EMC registers from reading MRR registers */
882 int tegra_emc_set_rate(unsigned long rate)
883 {
884         int i;
885         u32 clk_setting;
886         const struct tegra14_emc_table *last_timing;
887         unsigned long flags;
888         s64 last_change_delay;
889
890         if (!tegra_emc_table)
891                 return -EINVAL;
892
893         /* Table entries specify rate in kHz */
894         rate = rate / 1000;
895
896         i = get_start_idx(rate);
897         for (; i < tegra_emc_table_size; i++) {
898                 if (tegra_emc_clk_sel[i].input == NULL)
899                         continue;       /* invalid entry */
900
901                 if (tegra_emc_table[i].rate == rate)
902                         break;
903         }
904
905         if (i >= tegra_emc_table_size)
906                 return -EINVAL;
907
908         if (!emc_timing) {
909                 /* can not assume that boot timing matches dfs table even
910                    if boot frequency matches one of the table nodes */
911                 emc_get_timing(&start_timing);
912                 last_timing = &start_timing;
913         }
914         else
915                 last_timing = emc_timing;
916
917         clk_setting = tegra_emc_clk_sel[i].value;
918
919         last_change_delay = ktime_us_delta(ktime_get(), clkchange_time);
920         if ((last_change_delay >= 0) && (last_change_delay < clkchange_delay))
921                 udelay(clkchange_delay - (int)last_change_delay);
922
923         spin_lock_irqsave(&emc_access_lock, flags);
924         /* Pick from the EMC tables based on the status of the over temp state
925            flag. */
926         emc_set_clock(dram_over_temp_state != DRAM_OVER_TEMP_THROTTLE ?
927                       &tegra_emc_table[i] : &tegra_emc_table_derated[i],
928                       last_timing, clk_setting);
929         clkchange_time = timekeeping_suspended ? clkchange_time : ktime_get();
930         emc_timing = dram_over_temp_state != DRAM_OVER_TEMP_THROTTLE ?
931                 &tegra_emc_table[i] : &tegra_emc_table_derated[i];
932         if (dram_over_temp_state == DRAM_OVER_TEMP_THROTTLE)
933                 pr_debug("[emc] Picked derated freq.\n");
934         spin_unlock_irqrestore(&emc_access_lock, flags);
935
936         emc_last_stats_update(i);
937
938         pr_debug("%s: rate %lu setting 0x%x\n", __func__, rate, clk_setting);
939
940         return 0;
941 }
942
943 long tegra_emc_round_rate_updown(unsigned long rate, bool up)
944 {
945         int i;
946         unsigned long table_rate;
947
948         if (!tegra_emc_table)
949                 return clk_get_rate_locked(emc); /* no table - no rate change */
950
951         if (!emc_enable)
952                 return -EINVAL;
953
954         pr_debug("%s: %lu\n", __func__, rate);
955
956         /* Table entries specify rate in kHz */
957         rate = rate / 1000;
958
959         i = get_start_idx(rate);
960         for (; i < tegra_emc_table_size; i++) {
961                 if (tegra_emc_clk_sel[i].input == NULL)
962                         continue;       /* invalid entry */
963
964                 table_rate = tegra_emc_table[i].rate;
965                 if (table_rate >= rate) {
966                         if (!up && i && (table_rate > rate)) {
967                                 i--;
968                                 table_rate = tegra_emc_table[i].rate;
969                         }
970                         pr_debug("%s: using %lu\n", __func__, table_rate);
971                         last_round_idx = i;
972                         return table_rate * 1000;
973                 }
974         }
975
976         return -EINVAL;
977 }
978
979 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
980 {
981         int i;
982
983         if (!tegra_emc_table) {
984                 if (rate == clk_get_rate_locked(emc)) {
985                         *div_value = emc->div - 2;
986                         return emc->parent;
987                 }
988                 return NULL;
989         }
990
991         pr_debug("%s: %lu\n", __func__, rate);
992
993         /* Table entries specify rate in kHz */
994         rate = rate / 1000;
995
996         i = get_start_idx(rate);
997         for (; i < tegra_emc_table_size; i++) {
998                 if (tegra_emc_table[i].rate == rate) {
999                         struct clk *p = tegra_emc_clk_sel[i].input;
1000
1001                         if (p && (tegra_emc_clk_sel[i].input_rate ==
1002                                   clk_get_rate(p))) {
1003                                 *div_value = (tegra_emc_clk_sel[i].value &
1004                                         EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
1005                                 return p;
1006                         }
1007                 }
1008         }
1009         return NULL;
1010 }
1011
1012 bool tegra_emc_is_parent_ready(unsigned long rate, struct clk **parent,
1013                 unsigned long *parent_rate, unsigned long *backup_rate)
1014 {
1015
1016         int i;
1017         struct clk *p = NULL;
1018         unsigned long p_rate = 0;
1019
1020         if (!tegra_emc_table)
1021                 return true;
1022
1023         pr_debug("%s: %lu\n", __func__, rate);
1024
1025         /* Table entries specify rate in kHz */
1026         rate = rate / 1000;
1027
1028         i = get_start_idx(rate);
1029         for (; i < tegra_emc_table_size; i++) {
1030                 if (tegra_emc_table[i].rate == rate) {
1031                         p = tegra_emc_clk_sel[i].input;
1032                         if (!p)
1033                                 continue;       /* invalid entry */
1034
1035                         p_rate = tegra_emc_clk_sel[i].input_rate;
1036                         if (p_rate == clk_get_rate(p))
1037                                 return true;
1038                         break;
1039                 }
1040         }
1041
1042         /* Table match not found - "non existing parent" is ready */
1043         if (!p)
1044                 return true;
1045
1046 #ifdef CONFIG_TEGRA_PLLM_SCALED
1047         /*
1048          * Table match found, but parent is not ready - check if backup entry
1049          * was found during initialization, and return the respective backup
1050          * rate
1051          */
1052         if (emc->shared_bus_backup.input &&
1053             (emc->shared_bus_backup.input != p)) {
1054                 *parent = p;
1055                 *parent_rate = p_rate;
1056                 *backup_rate = emc->shared_bus_backup.bus_rate;
1057                 return false;
1058         }
1059 #else
1060         /*
1061          * Table match found, but parent is not ready - continue search
1062          * for backup rate: min rate above requested that has different
1063          * parent source (since only pll_c is scaled and may not be ready,
1064          * any other parent can provide backup)
1065          */
1066         *parent = p;
1067         *parent_rate = p_rate;
1068
1069         for (i++; i < tegra_emc_table_size; i++) {
1070                 p = tegra_emc_clk_sel[i].input;
1071                 if (!p)
1072                         continue;       /* invalid entry */
1073
1074                 if (p != (*parent)) {
1075                         *backup_rate = tegra_emc_table[i].rate * 1000;
1076                         return false;
1077                 }
1078         }
1079 #endif
1080         /* Parent is not ready, and no backup found */
1081         *backup_rate = -EINVAL;
1082         return false;
1083 }
1084
1085 static inline const struct clk_mux_sel *get_emc_input(u32 val)
1086 {
1087         const struct clk_mux_sel *sel;
1088
1089         for (sel = emc->inputs; sel->input != NULL; sel++) {
1090                 if (sel->value == val)
1091                         break;
1092         }
1093         return sel;
1094 }
1095
1096 static int find_matching_input(const struct tegra14_emc_table *table,
1097         struct clk *pll_c, struct clk *pll_m, struct emc_sel *emc_clk_sel)
1098 {
1099         u32 div_value = (table->src_sel_reg & EMC_CLK_DIV_MASK) >>
1100                 EMC_CLK_DIV_SHIFT;
1101         u32 src_value = (table->src_sel_reg & EMC_CLK_SOURCE_MASK) >>
1102                 EMC_CLK_SOURCE_SHIFT;
1103         unsigned long input_rate = 0;
1104         unsigned long table_rate = table->rate * 1000; /* table rate in kHz */
1105         const struct clk_mux_sel *sel = get_emc_input(src_value);
1106
1107 #ifdef CONFIG_TEGRA_PLLM_SCALED
1108         struct clk *scalable_pll = pll_m;
1109 #else
1110         struct clk *scalable_pll = pll_c;
1111 #endif
1112         pr_info_once("tegra: %s is selected as scalable EMC clock source\n",
1113                      scalable_pll->name);
1114
1115         if (div_value & 0x1) {
1116                 pr_warn("tegra: invalid odd divider for EMC rate %lu\n",
1117                         table_rate);
1118                 return -EINVAL;
1119         }
1120         if (!sel->input) {
1121                 pr_warn("tegra: no matching input found for EMC rate %lu\n",
1122                         table_rate);
1123                 return -EINVAL;
1124         }
1125         if (div_value && (table->src_sel_reg & EMC_CLK_LOW_JITTER_ENABLE)) {
1126                 pr_warn("tegra: invalid LJ path for EMC rate %lu\n",
1127                         table_rate);
1128                 return -EINVAL;
1129         }
1130         if (!(table->src_sel_reg & EMC_CLK_MC_SAME_FREQ) !=
1131             !(MC_EMEM_ARB_MISC0_EMC_SAME_FREQ &
1132               table->burst_regs[MC_EMEM_ARB_MISC0_INDEX])) {
1133                 pr_warn("tegra: ambiguous EMC to MC ratio for EMC rate %lu\n",
1134                         table_rate);
1135                 return -EINVAL;
1136         }
1137
1138 #ifndef CONFIG_TEGRA_DUAL_CBUS
1139         if (sel->input == pll_c) {
1140                 pr_warn("tegra: %s is cbus source: no EMC rate %lu support\n",
1141                         sel->input->name, table_rate);
1142                 return -EINVAL;
1143         }
1144 #endif
1145
1146         if (sel->input == scalable_pll) {
1147                 input_rate = table_rate * (1 + div_value / 2);
1148         } else {
1149                 /* all other sources are fixed, must exactly match the rate */
1150                 input_rate = clk_get_rate(sel->input);
1151                 if (input_rate != (table_rate * (1 + div_value / 2))) {
1152                         pr_warn("tegra: EMC rate %lu does not match %s rate %lu\n",
1153                                 table_rate, sel->input->name, input_rate);
1154                         return -EINVAL;
1155                 }
1156         }
1157
1158 #ifdef CONFIG_TEGRA_PLLM_SCALED
1159                 if (sel->input == pll_c) {
1160                         /* maybe overwritten in a loop - end up at max rate
1161                            from pll_c */
1162                         emc->shared_bus_backup.input = pll_c;
1163                         emc->shared_bus_backup.bus_rate = table_rate;
1164                 }
1165 #endif
1166         /* Get ready emc clock selection settings for this table rate */
1167         emc_clk_sel->input = sel->input;
1168         emc_clk_sel->input_rate = input_rate;
1169         emc_clk_sel->value = table->src_sel_reg;
1170
1171         return 0;
1172 }
1173
1174 static void adjust_emc_dvfs_table(const struct tegra14_emc_table *table,
1175                                   int table_size)
1176 {
1177         int i, j;
1178         unsigned long rate;
1179
1180         for (i = 0; i < MAX_DVFS_FREQS; i++) {
1181                 int mv = emc->dvfs->millivolts[i];
1182                 if (!mv)
1183                         break;
1184
1185                 /* For each dvfs voltage find maximum supported rate;
1186                    use 1MHz placeholder if not found */
1187                 for (rate = 1000, j = 0; j < table_size; j++) {
1188                         if (tegra_emc_clk_sel[j].input == NULL)
1189                                 continue;       /* invalid entry */
1190
1191                         if ((mv >= table[j].emc_min_mv) &&
1192                             (rate < table[j].rate))
1193                                 rate = table[j].rate;
1194                 }
1195                 /* Table entries specify rate in kHz */
1196                 emc->dvfs->freqs[i] = rate * 1000;
1197         }
1198 }
1199
1200 #ifdef CONFIG_TEGRA_PLLM_SCALED
1201 /* When pll_m is scaled, pll_c must provide backup rate;
1202    if not - remove rates that require pll_m scaling */
1203 static int purge_emc_table(unsigned long max_rate)
1204 {
1205         int i;
1206         int ret = 0;
1207
1208         if (emc->shared_bus_backup.input)
1209                 return ret;
1210
1211         pr_warn("tegra: selected pll_m scaling option but no backup source:\n");
1212         pr_warn("       removed not supported entries from the table:\n");
1213
1214         /* made all entries with non matching rate invalid */
1215         for (i = 0; i < tegra_emc_table_size; i++) {
1216                 struct emc_sel *sel = &tegra_emc_clk_sel[i];
1217                 if (sel->input) {
1218                         if (clk_get_rate(sel->input) != sel->input_rate) {
1219                                 pr_warn("       EMC rate %lu\n",
1220                                         tegra_emc_table[i].rate * 1000);
1221                                 sel->input = NULL;
1222                                 sel->input_rate = 0;
1223                                 sel->value = 0;
1224                                 if (max_rate == tegra_emc_table[i].rate)
1225                                         ret = -EINVAL;
1226                         }
1227                 }
1228         }
1229         return ret;
1230 }
1231 #else
1232 /* When pll_m is fixed @ max EMC rate, it always provides backup for pll_c */
1233 #define purge_emc_table(max_rate) (0)
1234 #endif
1235
1236 static int init_emc_table(const struct tegra14_emc_table *table,
1237                           const struct tegra14_emc_table *table_der,
1238                           int table_size)
1239 {
1240         int i, mv;
1241         u32 reg;
1242         bool max_entry = false;
1243         bool emc_max_dvfs_sel = get_emc_max_dvfs();
1244         unsigned long boot_rate, max_rate;
1245         struct clk *pll_c = tegra_get_clock_by_name("pll_c");
1246         struct clk *pll_m = tegra_get_clock_by_name("pll_m");
1247
1248         emc_stats.clkchange_count = 0;
1249         spin_lock_init(&emc_stats.spinlock);
1250         emc_stats.last_update = get_jiffies_64();
1251         emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
1252
1253         if (dram_type != DRAM_TYPE_LPDDR2) {
1254                 pr_err("tegra: not supported DRAM type %u\n", dram_type);
1255                 return -ENODATA;
1256         }
1257
1258         if (!table || !table_size) {
1259                 pr_err("tegra: EMC DFS table is empty\n");
1260                 return -ENODATA;
1261         }
1262
1263         boot_rate = clk_get_rate(emc) / 1000;
1264         max_rate = boot_rate;
1265
1266         tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
1267         switch (table[0].rev) {
1268         case 0x50:
1269         case 0x51:
1270                 pr_err("tegra: invalid EMC DFS table (0x%02x): too old.\n",
1271                        table[0].rev);
1272                 break;
1273         case 0x52:
1274                 start_timing.burst_regs_num = table[0].burst_regs_num;
1275                 break;
1276         default:
1277                 pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
1278                         table[0].rev);
1279                 return -ENODATA;
1280         }
1281
1282         /* Check that the derated table and non-derated table match. */
1283         if (WARN(!table_der, "tegra: emc: Missing derated tables!\n"))
1284                 return -EINVAL;
1285         for (i = 0; i < tegra_emc_table_size; i++) {
1286                 if (table[i].rate        != table_der[i].rate ||
1287                     table[i].rev         != table_der[i].rev ||
1288                     table[i].emc_min_mv  != table_der[i].emc_min_mv ||
1289                     table[i].src_sel_reg != table_der[i].src_sel_reg) {
1290                         pr_err("tegra: emc: Derated table mismatch.\n");
1291                         return -EINVAL;
1292                 }
1293         }
1294         pr_info("tegra: emc: Derated table is valid.\n");
1295
1296         /* Match EMC source/divider settings with table entries */
1297         for (i = 0; i < tegra_emc_table_size; i++) {
1298                 unsigned long table_rate = table[i].rate;
1299
1300                 /* Skip "no-rate" entry, or entry violating ascending order */
1301                 if (!table_rate ||
1302                     (i && (table_rate <= table[i-1].rate)))
1303                         continue;
1304
1305                 BUG_ON(table[i].rev != table[0].rev);
1306
1307                 if (find_matching_input(&table[i], pll_c, pll_m,
1308                                         &tegra_emc_clk_sel[i]))
1309                         continue;
1310
1311                 if (table_rate == boot_rate)
1312                         emc_stats.last_sel = i;
1313
1314                 if (emc_max_dvfs_sel) {
1315                         /* EMC max rate = max table entry above boot rate */
1316                         if (table_rate >= max_rate) {
1317                                 max_rate = table_rate;
1318                                 max_entry = true;
1319                         }
1320                 } else if (table_rate == max_rate) {
1321                         /* EMC max rate = boot rate */
1322                         max_entry = true;
1323                         break;
1324                 }
1325         }
1326
1327         /* Validate EMC rate and voltage limits */
1328         if (!max_entry) {
1329                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
1330                        " %lu kHz is not found\n", max_rate);
1331                 return -ENODATA;
1332         }
1333
1334         tegra_emc_table = table;
1335         tegra_emc_table_derated = table_der;
1336
1337         /*
1338          * Purge rates that cannot be reached because table does not specify
1339          * proper backup source. If maximum rate was purged, fall back on boot
1340          * rate as maximum limit. In any case propagate new maximum limit
1341          * down stream to shared users, and check it against nominal voltage.
1342          */
1343         if (purge_emc_table(max_rate))
1344                 max_rate = boot_rate;
1345         tegra_init_max_rate(emc, max_rate * 1000);
1346
1347         if (emc->dvfs) {
1348                 adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
1349                 mv = tegra_dvfs_predict_millivolts(emc, max_rate * 1000);
1350                 if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
1351                         tegra_emc_table = NULL;
1352                         pr_err("tegra: invalid EMC DFS table: maximum rate %lu"
1353                                " kHz does not match nominal voltage %d\n",
1354                                max_rate, emc->dvfs->max_millivolts);
1355                         return -ENODATA;
1356                 }
1357         }
1358
1359         pr_info("tegra: validated EMC DFS table\n");
1360
1361         /* Configure clock change mode according to dram type */
1362         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
1363         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
1364                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
1365         emc_writel(reg, EMC_CFG_2);
1366
1367 #if defined(CONFIG_TEGRA_ERRATA_1252872)
1368         emc_writel(tegra_emc_table->emc_acal_interval, EMC_AUTO_CAL_INTERVAL);
1369         emc_timing_update();
1370 #endif
1371         return 0;
1372 }
1373
1374 #ifdef CONFIG_PASR
1375 /* Check if the attached memory device uses LPDDR3 protocol.
1376  * Bit 8 (enable LPDDR3 write preamble toggle) of EMC_FBIO_SPARE is enabled
1377  * for LPDDR3.
1378  */
1379 static bool tegra14_is_lpddr3(void)
1380 {
1381         return emc_readl(EMC_FBIO_SPARE) & BIT(8);
1382 }
1383
1384 static void tegra14_pasr_apply_mask(u16 *mem_reg, void *cookie)
1385 {
1386         u32 val = 0;
1387         int device = (int)cookie;
1388
1389         val = TEGRA_EMC_MODE_REG_17 | *mem_reg;
1390         val |= device << TEGRA_EMC_MRW_DEV_SHIFT;
1391
1392         emc_writel(val, EMC_MRW);
1393
1394         pr_debug("%s: cookie = %d mem_reg = 0x%04x val = 0x%08x\n", __func__,
1395                         (int)cookie, *mem_reg, val);
1396 }
1397
1398 static int tegra14_pasr_enable(const char *arg, const struct kernel_param *kp)
1399 {
1400         unsigned int old_pasr_enable;
1401         void *cookie;
1402         u16 mem_reg;
1403         unsigned long device_size;
1404
1405         if (!tegra14_is_lpddr3())
1406                 return -ENOSYS;
1407
1408         old_pasr_enable = pasr_enable;
1409         param_set_int(arg, kp);
1410
1411         if (old_pasr_enable == pasr_enable)
1412                 return 0;
1413
1414         device_size = (mc_readl(TEGRA_MC_EMEM_ADR_CFG_DEV) >>
1415                                 TEGRA_EMEM_DEV_DEVSIZE_SHIFT) &
1416                                 TEGRA_EMEM_DEV_DEVSIZE_MASK;
1417         device_size = (4 << device_size) << 20;
1418
1419         /* Cookie represents the device number to write to MRW register.
1420          * 0x2 to for only dev0, 0x1 for dev1.
1421          */
1422         if (pasr_enable == 0) {
1423                 mem_reg = 0;
1424
1425                 cookie = (void *)(int)TEGRA_EMC_MRW_DEV1;
1426                 if (!pasr_register_mask_function(TEGRA_DRAM_BASE,
1427                                                         NULL, cookie))
1428                         tegra14_pasr_apply_mask(&mem_reg, cookie);
1429                 cookie = (void *)(int)TEGRA_EMC_MRW_DEV2;
1430                 if (!pasr_register_mask_function(TEGRA_DRAM_BASE + device_size,
1431                                                         NULL, cookie))
1432                         tegra14_pasr_apply_mask(&mem_reg, cookie);
1433         } else {
1434                 cookie = (void *)(int)2;
1435                 pasr_register_mask_function(TEGRA_DRAM_BASE,
1436                                         &tegra14_pasr_apply_mask, cookie);
1437
1438                 cookie = (void *)(int)1;
1439                 pasr_register_mask_function(TEGRA_DRAM_BASE + device_size,
1440                                         &tegra14_pasr_apply_mask, cookie);
1441         }
1442
1443         return 0;
1444 }
1445
1446 static struct kernel_param_ops tegra14_pasr_enable_ops = {
1447         .set = tegra14_pasr_enable,
1448         .get = param_get_int,
1449 };
1450 module_param_cb(pasr_enable, &tegra14_pasr_enable_ops, &pasr_enable, 0644);
1451 #endif
1452
1453 static int tegra14_emc_probe(struct platform_device *pdev)
1454 {
1455         struct tegra14_emc_pdata *pdata;
1456         struct resource *res;
1457         u32 padctrl;
1458
1459         pasr_enable = 0;
1460
1461         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1462         if (!res) {
1463                 dev_err(&pdev->dev, "missing register base\n");
1464                 return -ENOMEM;
1465         }
1466
1467         pdata = pdev->dev.platform_data;
1468         if (!pdata) {
1469                 dev_err(&pdev->dev, "missing platform data\n");
1470                 return -ENODATA;
1471         }
1472
1473 #if defined(CONFIG_TEGRA_ERRATA_1252872)
1474         padctrl = emc_readl(EMC_XM2CMDPADCTRL);
1475         padctrl &= ~(0x7 << 12);
1476         padctrl &= ~(0x7 << 20);
1477         emc_writel(padctrl, EMC_XM2CMDPADCTRL);
1478 #endif
1479
1480         return init_emc_table(pdata->tables, pdata->tables_derated,
1481                               pdata->num_tables);
1482 }
1483
1484 static struct platform_driver tegra14_emc_driver = {
1485         .driver         = {
1486                 .name   = "tegra-emc",
1487                 .owner  = THIS_MODULE,
1488         },
1489         .probe          = tegra14_emc_probe,
1490 };
1491
1492 int __init tegra14_emc_init(void)
1493 {
1494         int ret = platform_driver_register(&tegra14_emc_driver);
1495         if (!ret) {
1496                 tegra_emc_iso_usage_table_init(tegra14_emc_iso_usage,
1497                         ARRAY_SIZE(tegra14_emc_iso_usage));
1498                 if (emc_enable) {
1499                         unsigned long rate = tegra_emc_round_rate_updown(
1500                                 emc->boot_rate, false);
1501                         if (!IS_ERR_VALUE(rate))
1502                                 tegra_clk_preset_emc_monitor(rate);
1503                 }
1504         }
1505         return ret;
1506 }
1507
1508 void tegra_emc_timing_invalidate(void)
1509 {
1510         emc_timing = NULL;
1511 }
1512
1513 void tegra_emc_dram_type_init(struct clk *c)
1514 {
1515         emc = c;
1516
1517         dram_type = (emc_readl(EMC_FBIO_CFG5) &
1518                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
1519
1520         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
1521 }
1522
1523 int tegra_emc_get_dram_type(void)
1524 {
1525         return dram_type;
1526 }
1527
1528 static int emc_read_mrr(int dev, int addr)
1529 {
1530         int ret;
1531         u32 val, emc_cfg;
1532
1533         if (dram_type != DRAM_TYPE_LPDDR2)
1534                 return -ENODEV;
1535
1536         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, false);
1537         if (ret)
1538                 return ret;
1539
1540         emc_cfg = emc_readl(EMC_CFG);
1541         if (emc_cfg & EMC_CFG_DRAM_ACPD) {
1542                 emc_writel(emc_cfg & ~EMC_CFG_DRAM_ACPD, EMC_CFG);
1543                 emc_timing_update();
1544         }
1545
1546         val = dev ? DRAM_DEV_SEL_1 : DRAM_DEV_SEL_0;
1547         val |= (addr << EMC_MRR_MA_SHIFT) & EMC_MRR_MA_MASK;
1548         emc_writel(val, EMC_MRR);
1549
1550         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, true);
1551         if (emc_cfg & EMC_CFG_DRAM_ACPD) {
1552                 emc_writel(emc_cfg, EMC_CFG);
1553                 emc_timing_update();
1554         }
1555         if (ret)
1556                 return ret;
1557
1558         val = emc_readl(EMC_MRR) & EMC_MRR_DATA_MASK;
1559         return val;
1560 }
1561
1562 int tegra_emc_get_dram_temperature(void)
1563 {
1564         int mr4;
1565         unsigned long flags;
1566
1567         spin_lock_irqsave(&emc_access_lock, flags);
1568
1569         mr4 = emc_read_mrr(0, 4);
1570         if (IS_ERR_VALUE(mr4)) {
1571                 spin_unlock_irqrestore(&emc_access_lock, flags);
1572                 return mr4;
1573         }
1574         spin_unlock_irqrestore(&emc_access_lock, flags);
1575
1576         mr4 = (mr4 & LPDDR2_MR4_TEMP_MASK) >> LPDDR2_MR4_TEMP_SHIFT;
1577         return mr4;
1578 }
1579
1580 int tegra_emc_dsr_override(int override)
1581 {
1582         int i, emc_cfg;
1583         unsigned long flags, rate;
1584         const struct tegra14_emc_table *tbl_timing;
1585
1586         if (override != TEGRA_EMC_DSR_NORMAL &&
1587             override != TEGRA_EMC_DSR_OVERRIDE)
1588                 return -EINVAL;
1589
1590         /* No-op. */
1591         if (override == dsr_override)
1592                 return 0;
1593
1594         spin_lock_irqsave(&emc_access_lock, flags);
1595
1596         dsr_override = override;
1597         emc_cfg = emc_readl(EMC_CFG);
1598
1599         /*
1600          * If override is specified, just turn off DSR. Otherwise follow the
1601          * state specified in the current rate's table entry. However, it is
1602          * possible that we will be booting (warm or cold) with a rate that
1603          * is not in the table. If this is the case, we cannot determine what
1604          * needs to happen so we will simply leave dsr_override set to 0 and
1605          * let the next clock change handle returning DSR state to the table's
1606          * state.
1607          */
1608         emc_cfg &= ~EMC_CFG_DYN_SREF_ENABLE;
1609         if (override == TEGRA_EMC_DSR_NORMAL) {
1610                 /* Get table entry for current rate if we don't have a valid
1611                    rate already. */
1612                 tbl_timing = emc_timing;
1613                 if (!tbl_timing) {
1614                         /* Without the table, we can't do anything here. */
1615                         if (!tegra_emc_table) {
1616                                 spin_unlock_irqrestore(&emc_access_lock, flags);
1617                                 return -EINVAL;
1618                         }
1619                         rate = clk_get_rate_all_locked(emc) / 1000;
1620                         for (i = 0; i < tegra_emc_table_size; i++) {
1621                                 if (tegra_emc_table[i].rate == rate) {
1622                                         tbl_timing = &tegra_emc_table[i];
1623                                         break;
1624                                 }
1625                         }
1626                 }
1627
1628                 if (tbl_timing && tbl_timing->emc_cfg & EMC_CFG_DYN_SREF_ENABLE)
1629                         emc_cfg |= EMC_CFG_DYN_SREF_ENABLE;
1630         }
1631
1632         emc_writel(emc_cfg, EMC_CFG);
1633         emc_timing_update();
1634         spin_unlock_irqrestore(&emc_access_lock, flags);
1635         return 0;
1636 }
1637
1638 int tegra_emc_dsr_override_status(void)
1639 {
1640         return dsr_override;
1641 }
1642
1643 int tegra_emc_dsr_status(void)
1644 {
1645         int emc_cfg = emc_readl(EMC_CFG);
1646
1647         if (emc_cfg & EMC_CFG_DYN_SREF_ENABLE)
1648                 return 1;
1649         else
1650                 return 0;
1651 }
1652
1653 int tegra_emc_set_over_temp_state(unsigned long state)
1654 {
1655         int offset;
1656         unsigned long flags;
1657
1658         if (dram_type != DRAM_TYPE_LPDDR2 || !emc_timing)
1659                 return -ENODEV;
1660
1661         if (state > DRAM_OVER_TEMP_THROTTLE)
1662                 return -EINVAL;
1663
1664         /* Silently do nothing if there is no state change. */
1665         if (state == dram_over_temp_state)
1666                 return 0;
1667
1668         /*
1669          * If derating needs to be turned on/off force a clock change. That
1670          * will take care of the refresh as well. In derating is not going to
1671          * be changed then all that is needed is an update to the refresh
1672          * settings.
1673          */
1674         spin_lock_irqsave(&emc_access_lock, flags);
1675         if (state == DRAM_OVER_TEMP_THROTTLE) {
1676                 dram_over_temp_state = state;
1677                 offset = emc_timing - tegra_emc_table;
1678                 emc_set_clock(emc_timing, &tegra_emc_table_derated[offset],
1679                               tegra_emc_clk_sel[offset].value |
1680                               EMC_CLK_FORCE_CC_TRIGGER);
1681                 emc_timing = &tegra_emc_table_derated[offset];
1682         } else if (dram_over_temp_state == DRAM_OVER_TEMP_THROTTLE) {
1683                 dram_over_temp_state = state;
1684                 offset = emc_timing - tegra_emc_table_derated;
1685                 emc_set_clock(emc_timing, &tegra_emc_table[offset],
1686                               tegra_emc_clk_sel[offset].value |
1687                               EMC_CLK_FORCE_CC_TRIGGER);
1688                 emc_timing = &tegra_emc_table[offset];
1689         } else {
1690                 set_over_temp_timing(emc_timing, state);
1691                 emc_timing_update();
1692                 if (state != DRAM_OVER_TEMP_NONE)
1693                         emc_writel(EMC_REF_FORCE_CMD, EMC_REF);
1694                 dram_over_temp_state = state;
1695         }
1696         spin_unlock_irqrestore(&emc_access_lock, flags);
1697
1698         return 0;
1699 }
1700
1701 #ifdef CONFIG_DEBUG_FS
1702
1703 static struct dentry *emc_debugfs_root;
1704
1705 static int emc_stats_show(struct seq_file *s, void *data)
1706 {
1707         int i;
1708
1709         emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE);
1710
1711         seq_printf(s, "%-10s %-10s \n", "rate kHz", "time");
1712         for (i = 0; i < tegra_emc_table_size; i++) {
1713                 if (tegra_emc_clk_sel[i].input == NULL)
1714                         continue;       /* invalid entry */
1715
1716                 seq_printf(s, "%-10lu %-10llu \n", tegra_emc_table[i].rate,
1717                            cputime64_to_clock_t(emc_stats.time_at_clock[i]));
1718         }
1719         seq_printf(s, "%-15s %llu\n", "transitions:",
1720                    emc_stats.clkchange_count);
1721         seq_printf(s, "%-15s %llu\n", "time-stamp:",
1722                    cputime64_to_clock_t(emc_stats.last_update));
1723
1724         return 0;
1725 }
1726
1727 static int emc_stats_open(struct inode *inode, struct file *file)
1728 {
1729         return single_open(file, emc_stats_show, inode->i_private);
1730 }
1731
1732 static const struct file_operations emc_stats_fops = {
1733         .open           = emc_stats_open,
1734         .read           = seq_read,
1735         .llseek         = seq_lseek,
1736         .release        = single_release,
1737 };
1738
1739 static int emc_table_info_show(struct seq_file *s, void *data)
1740 {
1741         int i;
1742
1743         seq_printf(s, "Table info:\n");
1744         seq_printf(s, "  Rev: 0x%02x\n", tegra_emc_table->rev);
1745         seq_printf(s, "  Table ID: %s\n", tegra_emc_table->table_id);
1746         seq_printf(s, "  Possible rates (kHz):\n");
1747
1748         for (i = 0; i < tegra_emc_table_size; i++) {
1749                 if (tegra_emc_clk_sel[i].input == NULL)
1750                         continue;
1751                 seq_printf(s, "    %lu\n", tegra_emc_table[i].rate);
1752         }
1753
1754         return 0;
1755 }
1756
1757 static int emc_table_info_open(struct inode *inode, struct file *file)
1758 {
1759         return single_open(file, emc_table_info_show, inode->i_private);
1760 }
1761
1762 static const struct file_operations emc_table_info_fops = {
1763         .open           = emc_table_info_open,
1764         .read           = seq_read,
1765         .llseek         = seq_lseek,
1766         .release        = single_release,
1767 };
1768
1769 static int dram_temperature_get(void *data, u64 *val)
1770 {
1771         *val = tegra_emc_get_dram_temperature();
1772         return 0;
1773 }
1774 DEFINE_SIMPLE_ATTRIBUTE(dram_temperature_fops, dram_temperature_get,
1775                         NULL, "%lld\n");
1776
1777 static int over_temp_state_get(void *data, u64 *val)
1778 {
1779         *val = dram_over_temp_state;
1780         return 0;
1781 }
1782 static int over_temp_state_set(void *data, u64 val)
1783 {
1784         return tegra_emc_set_over_temp_state(val);
1785 }
1786 DEFINE_SIMPLE_ATTRIBUTE(over_temp_state_fops, over_temp_state_get,
1787                         over_temp_state_set, "%llu\n");
1788
1789 static int efficiency_get(void *data, u64 *val)
1790 {
1791         *val = tegra_emc_bw_efficiency;
1792         return 0;
1793 }
1794 static int efficiency_set(void *data, u64 val)
1795 {
1796         tegra_emc_bw_efficiency = (val > 100) ? 100 : val;
1797         if (emc)
1798                 tegra_clk_shared_bus_update(emc);
1799
1800         return 0;
1801 }
1802 DEFINE_SIMPLE_ATTRIBUTE(efficiency_fops, efficiency_get,
1803                         efficiency_set, "%llu\n");
1804
1805 static int dsr_get(void *data, u64 *val)
1806 {
1807         *val = tegra_emc_dsr_status();
1808         return 0;
1809 }
1810 DEFINE_SIMPLE_ATTRIBUTE(dsr_fops, dsr_get, NULL, "%llu\n");
1811
1812 static int dsr_override_set(void *data, u64 val)
1813 {
1814         if (val)
1815                 tegra_emc_dsr_override(TEGRA_EMC_DSR_OVERRIDE);
1816         else
1817                 tegra_emc_dsr_override(TEGRA_EMC_DSR_NORMAL);
1818
1819         return 0;
1820 }
1821
1822 static int dsr_override_get(void *data, u64 *val)
1823 {
1824         *val = tegra_emc_dsr_override_status();
1825         return 0;
1826 }
1827 DEFINE_SIMPLE_ATTRIBUTE(dsr_override_fops, dsr_override_get,
1828                         dsr_override_set, "%llu\n");
1829
1830 static int __init tegra_emc_debug_init(void)
1831 {
1832         if (!tegra_emc_table)
1833                 return 0;
1834
1835         emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL);
1836         if (!emc_debugfs_root)
1837                 return -ENOMEM;
1838
1839         if (!debugfs_create_file(
1840                 "stats", S_IRUGO, emc_debugfs_root, NULL, &emc_stats_fops))
1841                 goto err_out;
1842
1843         if (!debugfs_create_u32("clkchange_delay", S_IRUGO | S_IWUSR,
1844                 emc_debugfs_root, (u32 *)&clkchange_delay))
1845                 goto err_out;
1846
1847         if (!debugfs_create_file("dram_temperature", S_IRUGO, emc_debugfs_root,
1848                                  NULL, &dram_temperature_fops))
1849                 goto err_out;
1850
1851         if (!debugfs_create_file("over_temp_state", S_IRUGO | S_IWUSR,
1852                                  emc_debugfs_root, NULL, &over_temp_state_fops))
1853                 goto err_out;
1854
1855         if (!debugfs_create_file("efficiency", S_IRUGO | S_IWUSR,
1856                                  emc_debugfs_root, NULL, &efficiency_fops))
1857                 goto err_out;
1858
1859         if (!debugfs_create_file("dsr", S_IRUGO | S_IWUSR,
1860                                  emc_debugfs_root, NULL, &dsr_fops))
1861                 goto err_out;
1862
1863         if (!debugfs_create_file("dsr_override", S_IRUGO | S_IWUSR,
1864                                  emc_debugfs_root, NULL, &dsr_override_fops))
1865                 goto err_out;
1866
1867         if (!debugfs_create_file("table_info", S_IRUGO | S_IWUSR,
1868                                  emc_debugfs_root, NULL, &emc_table_info_fops))
1869                 goto err_out;
1870
1871         if (tegra_emc_iso_usage_debugfs_init(emc_debugfs_root))
1872                 goto err_out;
1873
1874         return 0;
1875
1876 err_out:
1877         debugfs_remove_recursive(emc_debugfs_root);
1878         return -ENOMEM;
1879 }
1880
1881 late_initcall(tegra_emc_debug_init);
1882 #endif