ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[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         if (!timekeeping_suspended) {
920                 last_change_delay = ktime_us_delta(ktime_get(), clkchange_time);
921                 if ((last_change_delay >= 0) &&
922                     (last_change_delay < clkchange_delay))
923                         udelay(clkchange_delay - (int)last_change_delay);
924         }
925
926         spin_lock_irqsave(&emc_access_lock, flags);
927         /* Pick from the EMC tables based on the status of the over temp state
928            flag. */
929         emc_set_clock(dram_over_temp_state != DRAM_OVER_TEMP_THROTTLE ?
930                       &tegra_emc_table[i] : &tegra_emc_table_derated[i],
931                       last_timing, clk_setting);
932         clkchange_time = timekeeping_suspended ? clkchange_time : ktime_get();
933         emc_timing = dram_over_temp_state != DRAM_OVER_TEMP_THROTTLE ?
934                 &tegra_emc_table[i] : &tegra_emc_table_derated[i];
935         if (dram_over_temp_state == DRAM_OVER_TEMP_THROTTLE)
936                 pr_debug("[emc] Picked derated freq.\n");
937         spin_unlock_irqrestore(&emc_access_lock, flags);
938
939         emc_last_stats_update(i);
940
941         pr_debug("%s: rate %lu setting 0x%x\n", __func__, rate, clk_setting);
942
943         return 0;
944 }
945
946 long tegra_emc_round_rate_updown(unsigned long rate, bool up)
947 {
948         int i;
949         unsigned long table_rate;
950
951         if (!tegra_emc_table)
952                 return clk_get_rate_locked(emc); /* no table - no rate change */
953
954         if (!emc_enable)
955                 return -EINVAL;
956
957         pr_debug("%s: %lu\n", __func__, rate);
958
959         /* Table entries specify rate in kHz */
960         rate = rate / 1000;
961
962         i = get_start_idx(rate);
963         for (; i < tegra_emc_table_size; i++) {
964                 if (tegra_emc_clk_sel[i].input == NULL)
965                         continue;       /* invalid entry */
966
967                 table_rate = tegra_emc_table[i].rate;
968                 if (table_rate >= rate) {
969                         if (!up && i && (table_rate > rate)) {
970                                 i--;
971                                 table_rate = tegra_emc_table[i].rate;
972                         }
973                         pr_debug("%s: using %lu\n", __func__, table_rate);
974                         last_round_idx = i;
975                         return table_rate * 1000;
976                 }
977         }
978
979         return -EINVAL;
980 }
981
982 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
983 {
984         int i;
985
986         if (!tegra_emc_table) {
987                 if (rate == clk_get_rate_locked(emc)) {
988                         *div_value = emc->div - 2;
989                         return emc->parent;
990                 }
991                 return NULL;
992         }
993
994         pr_debug("%s: %lu\n", __func__, rate);
995
996         /* Table entries specify rate in kHz */
997         rate = rate / 1000;
998
999         i = get_start_idx(rate);
1000         for (; i < tegra_emc_table_size; i++) {
1001                 if (tegra_emc_table[i].rate == rate) {
1002                         struct clk *p = tegra_emc_clk_sel[i].input;
1003
1004                         if (p && (tegra_emc_clk_sel[i].input_rate ==
1005                                   clk_get_rate(p))) {
1006                                 *div_value = (tegra_emc_clk_sel[i].value &
1007                                         EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
1008                                 return p;
1009                         }
1010                 }
1011         }
1012         return NULL;
1013 }
1014
1015 bool tegra_emc_is_parent_ready(unsigned long rate, struct clk **parent,
1016                 unsigned long *parent_rate, unsigned long *backup_rate)
1017 {
1018
1019         int i;
1020         struct clk *p = NULL;
1021         unsigned long p_rate = 0;
1022
1023         if (!tegra_emc_table)
1024                 return true;
1025
1026         pr_debug("%s: %lu\n", __func__, rate);
1027
1028         /* Table entries specify rate in kHz */
1029         rate = rate / 1000;
1030
1031         i = get_start_idx(rate);
1032         for (; i < tegra_emc_table_size; i++) {
1033                 if (tegra_emc_table[i].rate == rate) {
1034                         p = tegra_emc_clk_sel[i].input;
1035                         if (!p)
1036                                 continue;       /* invalid entry */
1037
1038                         p_rate = tegra_emc_clk_sel[i].input_rate;
1039                         if (p_rate == clk_get_rate(p))
1040                                 return true;
1041                         break;
1042                 }
1043         }
1044
1045         /* Table match not found - "non existing parent" is ready */
1046         if (!p)
1047                 return true;
1048
1049 #ifdef CONFIG_TEGRA_PLLM_SCALED
1050         /*
1051          * Table match found, but parent is not ready - check if backup entry
1052          * was found during initialization, and return the respective backup
1053          * rate
1054          */
1055         if (emc->shared_bus_backup.input &&
1056             (emc->shared_bus_backup.input != p)) {
1057                 *parent = p;
1058                 *parent_rate = p_rate;
1059                 *backup_rate = emc->shared_bus_backup.bus_rate;
1060                 return false;
1061         }
1062 #else
1063         /*
1064          * Table match found, but parent is not ready - continue search
1065          * for backup rate: min rate above requested that has different
1066          * parent source (since only pll_c is scaled and may not be ready,
1067          * any other parent can provide backup)
1068          */
1069         *parent = p;
1070         *parent_rate = p_rate;
1071
1072         for (i++; i < tegra_emc_table_size; i++) {
1073                 p = tegra_emc_clk_sel[i].input;
1074                 if (!p)
1075                         continue;       /* invalid entry */
1076
1077                 if (p != (*parent)) {
1078                         *backup_rate = tegra_emc_table[i].rate * 1000;
1079                         return false;
1080                 }
1081         }
1082 #endif
1083         /* Parent is not ready, and no backup found */
1084         *backup_rate = -EINVAL;
1085         return false;
1086 }
1087
1088 static inline const struct clk_mux_sel *get_emc_input(u32 val)
1089 {
1090         const struct clk_mux_sel *sel;
1091
1092         for (sel = emc->inputs; sel->input != NULL; sel++) {
1093                 if (sel->value == val)
1094                         break;
1095         }
1096         return sel;
1097 }
1098
1099 static int find_matching_input(const struct tegra14_emc_table *table,
1100         struct clk *pll_c, struct clk *pll_m, struct emc_sel *emc_clk_sel)
1101 {
1102         u32 div_value = (table->src_sel_reg & EMC_CLK_DIV_MASK) >>
1103                 EMC_CLK_DIV_SHIFT;
1104         u32 src_value = (table->src_sel_reg & EMC_CLK_SOURCE_MASK) >>
1105                 EMC_CLK_SOURCE_SHIFT;
1106         unsigned long input_rate = 0;
1107         unsigned long table_rate = table->rate * 1000; /* table rate in kHz */
1108         const struct clk_mux_sel *sel = get_emc_input(src_value);
1109
1110 #ifdef CONFIG_TEGRA_PLLM_SCALED
1111         struct clk *scalable_pll = pll_m;
1112 #else
1113         struct clk *scalable_pll = pll_c;
1114 #endif
1115         pr_info_once("tegra: %s is selected as scalable EMC clock source\n",
1116                      scalable_pll->name);
1117
1118         if (div_value & 0x1) {
1119                 pr_warn("tegra: invalid odd divider for EMC rate %lu\n",
1120                         table_rate);
1121                 return -EINVAL;
1122         }
1123         if (!sel->input) {
1124                 pr_warn("tegra: no matching input found for EMC rate %lu\n",
1125                         table_rate);
1126                 return -EINVAL;
1127         }
1128         if (div_value && (table->src_sel_reg & EMC_CLK_LOW_JITTER_ENABLE)) {
1129                 pr_warn("tegra: invalid LJ path for EMC rate %lu\n",
1130                         table_rate);
1131                 return -EINVAL;
1132         }
1133         if (!(table->src_sel_reg & EMC_CLK_MC_SAME_FREQ) !=
1134             !(MC_EMEM_ARB_MISC0_EMC_SAME_FREQ &
1135               table->burst_regs[MC_EMEM_ARB_MISC0_INDEX])) {
1136                 pr_warn("tegra: ambiguous EMC to MC ratio for EMC rate %lu\n",
1137                         table_rate);
1138                 return -EINVAL;
1139         }
1140
1141 #ifndef CONFIG_TEGRA_DUAL_CBUS
1142         if (sel->input == pll_c) {
1143                 pr_warn("tegra: %s is cbus source: no EMC rate %lu support\n",
1144                         sel->input->name, table_rate);
1145                 return -EINVAL;
1146         }
1147 #endif
1148
1149         if (sel->input == scalable_pll) {
1150                 input_rate = table_rate * (1 + div_value / 2);
1151         } else {
1152                 /* all other sources are fixed, must exactly match the rate */
1153                 input_rate = clk_get_rate(sel->input);
1154                 if (input_rate != (table_rate * (1 + div_value / 2))) {
1155                         pr_warn("tegra: EMC rate %lu does not match %s rate %lu\n",
1156                                 table_rate, sel->input->name, input_rate);
1157                         return -EINVAL;
1158                 }
1159         }
1160
1161 #ifdef CONFIG_TEGRA_PLLM_SCALED
1162                 if (sel->input == pll_c) {
1163                         /* maybe overwritten in a loop - end up at max rate
1164                            from pll_c */
1165                         emc->shared_bus_backup.input = pll_c;
1166                         emc->shared_bus_backup.bus_rate = table_rate;
1167                 }
1168 #endif
1169         /* Get ready emc clock selection settings for this table rate */
1170         emc_clk_sel->input = sel->input;
1171         emc_clk_sel->input_rate = input_rate;
1172         emc_clk_sel->value = table->src_sel_reg;
1173
1174         return 0;
1175 }
1176
1177 static void adjust_emc_dvfs_table(const struct tegra14_emc_table *table,
1178                                   int table_size)
1179 {
1180         int i, j;
1181         unsigned long rate;
1182
1183         for (i = 0; i < MAX_DVFS_FREQS; i++) {
1184                 int mv = emc->dvfs->millivolts[i];
1185                 if (!mv)
1186                         break;
1187
1188                 /* For each dvfs voltage find maximum supported rate;
1189                    use 1MHz placeholder if not found */
1190                 for (rate = 1000, j = 0; j < table_size; j++) {
1191                         if (tegra_emc_clk_sel[j].input == NULL)
1192                                 continue;       /* invalid entry */
1193
1194                         if ((mv >= table[j].emc_min_mv) &&
1195                             (rate < table[j].rate))
1196                                 rate = table[j].rate;
1197                 }
1198                 /* Table entries specify rate in kHz */
1199                 emc->dvfs->freqs[i] = rate * 1000;
1200         }
1201 }
1202
1203 #ifdef CONFIG_TEGRA_PLLM_SCALED
1204 /* When pll_m is scaled, pll_c must provide backup rate;
1205    if not - remove rates that require pll_m scaling */
1206 static int purge_emc_table(unsigned long max_rate)
1207 {
1208         int i;
1209         int ret = 0;
1210
1211         if (emc->shared_bus_backup.input)
1212                 return ret;
1213
1214         pr_warn("tegra: selected pll_m scaling option but no backup source:\n");
1215         pr_warn("       removed not supported entries from the table:\n");
1216
1217         /* made all entries with non matching rate invalid */
1218         for (i = 0; i < tegra_emc_table_size; i++) {
1219                 struct emc_sel *sel = &tegra_emc_clk_sel[i];
1220                 if (sel->input) {
1221                         if (clk_get_rate(sel->input) != sel->input_rate) {
1222                                 pr_warn("       EMC rate %lu\n",
1223                                         tegra_emc_table[i].rate * 1000);
1224                                 sel->input = NULL;
1225                                 sel->input_rate = 0;
1226                                 sel->value = 0;
1227                                 if (max_rate == tegra_emc_table[i].rate)
1228                                         ret = -EINVAL;
1229                         }
1230                 }
1231         }
1232         return ret;
1233 }
1234 #else
1235 /* When pll_m is fixed @ max EMC rate, it always provides backup for pll_c */
1236 #define purge_emc_table(max_rate) (0)
1237 #endif
1238
1239 static int init_emc_table(const struct tegra14_emc_table *table,
1240                           const struct tegra14_emc_table *table_der,
1241                           int table_size)
1242 {
1243         int i, mv;
1244         u32 reg;
1245         bool max_entry = false;
1246         bool emc_max_dvfs_sel = get_emc_max_dvfs();
1247         unsigned long boot_rate, max_rate;
1248         struct clk *pll_c = tegra_get_clock_by_name("pll_c");
1249         struct clk *pll_m = tegra_get_clock_by_name("pll_m");
1250
1251         emc_stats.clkchange_count = 0;
1252         spin_lock_init(&emc_stats.spinlock);
1253         emc_stats.last_update = get_jiffies_64();
1254         emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
1255
1256         if (dram_type != DRAM_TYPE_LPDDR2) {
1257                 pr_err("tegra: not supported DRAM type %u\n", dram_type);
1258                 return -ENODATA;
1259         }
1260
1261         if (!table || !table_size) {
1262                 pr_err("tegra: EMC DFS table is empty\n");
1263                 return -ENODATA;
1264         }
1265
1266         boot_rate = clk_get_rate(emc) / 1000;
1267         max_rate = boot_rate;
1268
1269         tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
1270         switch (table[0].rev) {
1271         case 0x50:
1272         case 0x51:
1273                 pr_err("tegra: invalid EMC DFS table (0x%02x): too old.\n",
1274                        table[0].rev);
1275                 break;
1276         case 0x52:
1277                 start_timing.burst_regs_num = table[0].burst_regs_num;
1278                 break;
1279         default:
1280                 pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
1281                         table[0].rev);
1282                 return -ENODATA;
1283         }
1284
1285         /* Check that the derated table and non-derated table match. */
1286         if (WARN(!table_der, "tegra: emc: Missing derated tables!\n"))
1287                 return -EINVAL;
1288         for (i = 0; i < tegra_emc_table_size; i++) {
1289                 if (table[i].rate        != table_der[i].rate ||
1290                     table[i].rev         != table_der[i].rev ||
1291                     table[i].emc_min_mv  != table_der[i].emc_min_mv ||
1292                     table[i].src_sel_reg != table_der[i].src_sel_reg) {
1293                         pr_err("tegra: emc: Derated table mismatch.\n");
1294                         return -EINVAL;
1295                 }
1296         }
1297         pr_info("tegra: emc: Derated table is valid.\n");
1298
1299         /* Match EMC source/divider settings with table entries */
1300         for (i = 0; i < tegra_emc_table_size; i++) {
1301                 unsigned long table_rate = table[i].rate;
1302
1303                 /* Skip "no-rate" entry, or entry violating ascending order */
1304                 if (!table_rate ||
1305                     (i && (table_rate <= table[i-1].rate)))
1306                         continue;
1307
1308                 BUG_ON(table[i].rev != table[0].rev);
1309
1310                 if (find_matching_input(&table[i], pll_c, pll_m,
1311                                         &tegra_emc_clk_sel[i]))
1312                         continue;
1313
1314                 if (table_rate == boot_rate)
1315                         emc_stats.last_sel = i;
1316
1317                 if (emc_max_dvfs_sel) {
1318                         /* EMC max rate = max table entry above boot rate */
1319                         if (table_rate >= max_rate) {
1320                                 max_rate = table_rate;
1321                                 max_entry = true;
1322                         }
1323                 } else if (table_rate == max_rate) {
1324                         /* EMC max rate = boot rate */
1325                         max_entry = true;
1326                         break;
1327                 }
1328         }
1329
1330         /* Validate EMC rate and voltage limits */
1331         if (!max_entry) {
1332                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
1333                        " %lu kHz is not found\n", max_rate);
1334                 return -ENODATA;
1335         }
1336
1337         tegra_emc_table = table;
1338         tegra_emc_table_derated = table_der;
1339
1340         /*
1341          * Purge rates that cannot be reached because table does not specify
1342          * proper backup source. If maximum rate was purged, fall back on boot
1343          * rate as maximum limit. In any case propagate new maximum limit
1344          * down stream to shared users, and check it against nominal voltage.
1345          */
1346         if (purge_emc_table(max_rate))
1347                 max_rate = boot_rate;
1348         tegra_init_max_rate(emc, max_rate * 1000);
1349
1350         if (emc->dvfs) {
1351                 adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
1352                 mv = tegra_dvfs_predict_peak_millivolts(emc, max_rate * 1000);
1353                 if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
1354                         tegra_emc_table = NULL;
1355                         pr_err("tegra: invalid EMC DFS table: maximum rate %lu"
1356                                " kHz does not match nominal voltage %d\n",
1357                                max_rate, emc->dvfs->max_millivolts);
1358                         return -ENODATA;
1359                 }
1360         }
1361
1362         pr_info("tegra: validated EMC DFS table\n");
1363
1364         /* Configure clock change mode according to dram type */
1365         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
1366         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
1367                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
1368         emc_writel(reg, EMC_CFG_2);
1369
1370 #if defined(CONFIG_TEGRA_ERRATA_1252872)
1371         emc_writel(tegra_emc_table->emc_acal_interval, EMC_AUTO_CAL_INTERVAL);
1372         emc_timing_update();
1373 #endif
1374         return 0;
1375 }
1376
1377 #ifdef CONFIG_PASR
1378 /* Check if the attached memory device uses LPDDR3 protocol.
1379  * Bit 8 (enable LPDDR3 write preamble toggle) of EMC_FBIO_SPARE is enabled
1380  * for LPDDR3.
1381  */
1382 static bool tegra14_is_lpddr3(void)
1383 {
1384         return emc_readl(EMC_FBIO_SPARE) & BIT(8);
1385 }
1386
1387 static void tegra14_pasr_apply_mask(u16 *mem_reg, void *cookie)
1388 {
1389         u32 val = 0;
1390         int device = (int)cookie;
1391
1392         val = TEGRA_EMC_MODE_REG_17 | *mem_reg;
1393         val |= device << TEGRA_EMC_MRW_DEV_SHIFT;
1394
1395         emc_writel(val, EMC_MRW);
1396
1397         pr_debug("%s: cookie = %d mem_reg = 0x%04x val = 0x%08x\n", __func__,
1398                         (int)cookie, *mem_reg, val);
1399 }
1400
1401 static int tegra14_pasr_enable(const char *arg, const struct kernel_param *kp)
1402 {
1403         unsigned int old_pasr_enable;
1404         void *cookie;
1405         u16 mem_reg;
1406         unsigned long device_size;
1407
1408         if (!tegra14_is_lpddr3())
1409                 return -ENOSYS;
1410
1411         old_pasr_enable = pasr_enable;
1412         param_set_int(arg, kp);
1413
1414         if (old_pasr_enable == pasr_enable)
1415                 return 0;
1416
1417         device_size = (mc_readl(TEGRA_MC_EMEM_ADR_CFG_DEV) >>
1418                                 TEGRA_EMEM_DEV_DEVSIZE_SHIFT) &
1419                                 TEGRA_EMEM_DEV_DEVSIZE_MASK;
1420         device_size = (4 << device_size) << 20;
1421
1422         /* Cookie represents the device number to write to MRW register.
1423          * 0x2 to for only dev0, 0x1 for dev1.
1424          */
1425         if (pasr_enable == 0) {
1426                 mem_reg = 0;
1427
1428                 cookie = (void *)(int)TEGRA_EMC_MRW_DEV1;
1429                 if (!pasr_register_mask_function(TEGRA_DRAM_BASE,
1430                                                         NULL, cookie))
1431                         tegra14_pasr_apply_mask(&mem_reg, cookie);
1432                 cookie = (void *)(int)TEGRA_EMC_MRW_DEV2;
1433                 if (!pasr_register_mask_function(TEGRA_DRAM_BASE + device_size,
1434                                                         NULL, cookie))
1435                         tegra14_pasr_apply_mask(&mem_reg, cookie);
1436         } else {
1437                 cookie = (void *)(int)2;
1438                 pasr_register_mask_function(TEGRA_DRAM_BASE,
1439                                         &tegra14_pasr_apply_mask, cookie);
1440
1441                 cookie = (void *)(int)1;
1442                 pasr_register_mask_function(TEGRA_DRAM_BASE + device_size,
1443                                         &tegra14_pasr_apply_mask, cookie);
1444         }
1445
1446         return 0;
1447 }
1448
1449 static struct kernel_param_ops tegra14_pasr_enable_ops = {
1450         .set = tegra14_pasr_enable,
1451         .get = param_get_int,
1452 };
1453 module_param_cb(pasr_enable, &tegra14_pasr_enable_ops, &pasr_enable, 0644);
1454 #endif
1455
1456 static int tegra14_emc_probe(struct platform_device *pdev)
1457 {
1458         struct tegra14_emc_pdata *pdata;
1459         struct resource *res;
1460         u32 padctrl;
1461
1462         pasr_enable = 0;
1463
1464         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1465         if (!res) {
1466                 dev_err(&pdev->dev, "missing register base\n");
1467                 return -ENOMEM;
1468         }
1469
1470         pdata = pdev->dev.platform_data;
1471         if (!pdata) {
1472                 dev_err(&pdev->dev, "missing platform data\n");
1473                 return -ENODATA;
1474         }
1475
1476 #if defined(CONFIG_TEGRA_ERRATA_1252872)
1477         padctrl = emc_readl(EMC_XM2CMDPADCTRL);
1478         padctrl &= ~(0x7 << 12);
1479         padctrl &= ~(0x7 << 20);
1480         emc_writel(padctrl, EMC_XM2CMDPADCTRL);
1481 #endif
1482
1483         return init_emc_table(pdata->tables, pdata->tables_derated,
1484                               pdata->num_tables);
1485 }
1486
1487 static struct platform_driver tegra14_emc_driver = {
1488         .driver         = {
1489                 .name   = "tegra-emc",
1490                 .owner  = THIS_MODULE,
1491         },
1492         .probe          = tegra14_emc_probe,
1493 };
1494
1495 int __init tegra14_emc_init(void)
1496 {
1497         int ret = platform_driver_register(&tegra14_emc_driver);
1498         if (!ret) {
1499                 tegra_emc_iso_usage_table_init(tegra14_emc_iso_usage,
1500                         ARRAY_SIZE(tegra14_emc_iso_usage));
1501                 if (emc_enable) {
1502                         unsigned long rate = tegra_emc_round_rate_updown(
1503                                 emc->boot_rate, false);
1504                         if (!IS_ERR_VALUE(rate))
1505                                 tegra_clk_preset_emc_monitor(rate);
1506                 }
1507         }
1508         return ret;
1509 }
1510
1511 void tegra_emc_timing_invalidate(void)
1512 {
1513         emc_timing = NULL;
1514 }
1515
1516 void tegra_emc_dram_type_init(struct clk *c)
1517 {
1518         emc = c;
1519
1520         dram_type = (emc_readl(EMC_FBIO_CFG5) &
1521                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
1522
1523         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
1524 }
1525
1526 int tegra_emc_get_dram_type(void)
1527 {
1528         return dram_type;
1529 }
1530
1531 static int emc_read_mrr(int dev, int addr)
1532 {
1533         int ret;
1534         u32 val, emc_cfg;
1535
1536         if (dram_type != DRAM_TYPE_LPDDR2)
1537                 return -ENODEV;
1538
1539         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, false);
1540         if (ret)
1541                 return ret;
1542
1543         emc_cfg = emc_readl(EMC_CFG);
1544         if (emc_cfg & EMC_CFG_DRAM_ACPD) {
1545                 emc_writel(emc_cfg & ~EMC_CFG_DRAM_ACPD, EMC_CFG);
1546                 emc_timing_update();
1547         }
1548
1549         val = dev ? DRAM_DEV_SEL_1 : DRAM_DEV_SEL_0;
1550         val |= (addr << EMC_MRR_MA_SHIFT) & EMC_MRR_MA_MASK;
1551         emc_writel(val, EMC_MRR);
1552
1553         ret = wait_for_update(EMC_STATUS, EMC_STATUS_MRR_DIVLD, true);
1554         if (emc_cfg & EMC_CFG_DRAM_ACPD) {
1555                 emc_writel(emc_cfg, EMC_CFG);
1556                 emc_timing_update();
1557         }
1558         if (ret)
1559                 return ret;
1560
1561         val = emc_readl(EMC_MRR) & EMC_MRR_DATA_MASK;
1562         return val;
1563 }
1564
1565 int tegra_emc_get_dram_temperature(void)
1566 {
1567         int mr4;
1568         unsigned long flags;
1569
1570         spin_lock_irqsave(&emc_access_lock, flags);
1571
1572         mr4 = emc_read_mrr(0, 4);
1573         if (IS_ERR_VALUE(mr4)) {
1574                 spin_unlock_irqrestore(&emc_access_lock, flags);
1575                 return mr4;
1576         }
1577         spin_unlock_irqrestore(&emc_access_lock, flags);
1578
1579         mr4 = (mr4 & LPDDR2_MR4_TEMP_MASK) >> LPDDR2_MR4_TEMP_SHIFT;
1580         return mr4;
1581 }
1582
1583 int tegra_emc_dsr_override(int override)
1584 {
1585         int i, emc_cfg;
1586         unsigned long flags, rate;
1587         const struct tegra14_emc_table *tbl_timing;
1588
1589         if (override != TEGRA_EMC_DSR_NORMAL &&
1590             override != TEGRA_EMC_DSR_OVERRIDE)
1591                 return -EINVAL;
1592
1593         /* No-op. */
1594         if (override == dsr_override)
1595                 return 0;
1596
1597         spin_lock_irqsave(&emc_access_lock, flags);
1598
1599         dsr_override = override;
1600         emc_cfg = emc_readl(EMC_CFG);
1601
1602         /*
1603          * If override is specified, just turn off DSR. Otherwise follow the
1604          * state specified in the current rate's table entry. However, it is
1605          * possible that we will be booting (warm or cold) with a rate that
1606          * is not in the table. If this is the case, we cannot determine what
1607          * needs to happen so we will simply leave dsr_override set to 0 and
1608          * let the next clock change handle returning DSR state to the table's
1609          * state.
1610          */
1611         emc_cfg &= ~EMC_CFG_DYN_SREF_ENABLE;
1612         if (override == TEGRA_EMC_DSR_NORMAL) {
1613                 /* Get table entry for current rate if we don't have a valid
1614                    rate already. */
1615                 tbl_timing = emc_timing;
1616                 if (!tbl_timing) {
1617                         /* Without the table, we can't do anything here. */
1618                         if (!tegra_emc_table) {
1619                                 spin_unlock_irqrestore(&emc_access_lock, flags);
1620                                 return -EINVAL;
1621                         }
1622                         rate = clk_get_rate_all_locked(emc) / 1000;
1623                         for (i = 0; i < tegra_emc_table_size; i++) {
1624                                 if (tegra_emc_table[i].rate == rate) {
1625                                         tbl_timing = &tegra_emc_table[i];
1626                                         break;
1627                                 }
1628                         }
1629                 }
1630
1631                 if (tbl_timing && tbl_timing->emc_cfg & EMC_CFG_DYN_SREF_ENABLE)
1632                         emc_cfg |= EMC_CFG_DYN_SREF_ENABLE;
1633         }
1634
1635         emc_writel(emc_cfg, EMC_CFG);
1636         emc_timing_update();
1637         spin_unlock_irqrestore(&emc_access_lock, flags);
1638         return 0;
1639 }
1640
1641 int tegra_emc_dsr_override_status(void)
1642 {
1643         return dsr_override;
1644 }
1645
1646 int tegra_emc_dsr_status(void)
1647 {
1648         int emc_cfg = emc_readl(EMC_CFG);
1649
1650         if (emc_cfg & EMC_CFG_DYN_SREF_ENABLE)
1651                 return 1;
1652         else
1653                 return 0;
1654 }
1655
1656 int tegra_emc_set_over_temp_state(unsigned long state)
1657 {
1658         int offset;
1659         unsigned long flags;
1660
1661         if (dram_type != DRAM_TYPE_LPDDR2 || !emc_timing)
1662                 return -ENODEV;
1663
1664         if (state > DRAM_OVER_TEMP_THROTTLE)
1665                 return -EINVAL;
1666
1667         /* Silently do nothing if there is no state change. */
1668         if (state == dram_over_temp_state)
1669                 return 0;
1670
1671         /*
1672          * If derating needs to be turned on/off force a clock change. That
1673          * will take care of the refresh as well. In derating is not going to
1674          * be changed then all that is needed is an update to the refresh
1675          * settings.
1676          */
1677         spin_lock_irqsave(&emc_access_lock, flags);
1678         if (state == DRAM_OVER_TEMP_THROTTLE) {
1679                 dram_over_temp_state = state;
1680                 offset = emc_timing - tegra_emc_table;
1681                 emc_set_clock(emc_timing, &tegra_emc_table_derated[offset],
1682                               tegra_emc_clk_sel[offset].value |
1683                               EMC_CLK_FORCE_CC_TRIGGER);
1684                 emc_timing = &tegra_emc_table_derated[offset];
1685         } else if (dram_over_temp_state == DRAM_OVER_TEMP_THROTTLE) {
1686                 dram_over_temp_state = state;
1687                 offset = emc_timing - tegra_emc_table_derated;
1688                 emc_set_clock(emc_timing, &tegra_emc_table[offset],
1689                               tegra_emc_clk_sel[offset].value |
1690                               EMC_CLK_FORCE_CC_TRIGGER);
1691                 emc_timing = &tegra_emc_table[offset];
1692         } else {
1693                 set_over_temp_timing(emc_timing, state);
1694                 emc_timing_update();
1695                 if (state != DRAM_OVER_TEMP_NONE)
1696                         emc_writel(EMC_REF_FORCE_CMD, EMC_REF);
1697                 dram_over_temp_state = state;
1698         }
1699         spin_unlock_irqrestore(&emc_access_lock, flags);
1700
1701         return 0;
1702 }
1703
1704 #ifdef CONFIG_DEBUG_FS
1705
1706 static struct dentry *emc_debugfs_root;
1707
1708 static int emc_stats_show(struct seq_file *s, void *data)
1709 {
1710         int i;
1711
1712         emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE);
1713
1714         seq_printf(s, "%-10s %-10s \n", "rate kHz", "time");
1715         for (i = 0; i < tegra_emc_table_size; i++) {
1716                 if (tegra_emc_clk_sel[i].input == NULL)
1717                         continue;       /* invalid entry */
1718
1719                 seq_printf(s, "%-10lu %-10llu \n", tegra_emc_table[i].rate,
1720                            cputime64_to_clock_t(emc_stats.time_at_clock[i]));
1721         }
1722         seq_printf(s, "%-15s %llu\n", "transitions:",
1723                    emc_stats.clkchange_count);
1724         seq_printf(s, "%-15s %llu\n", "time-stamp:",
1725                    cputime64_to_clock_t(emc_stats.last_update));
1726
1727         return 0;
1728 }
1729
1730 static int emc_stats_open(struct inode *inode, struct file *file)
1731 {
1732         return single_open(file, emc_stats_show, inode->i_private);
1733 }
1734
1735 static const struct file_operations emc_stats_fops = {
1736         .open           = emc_stats_open,
1737         .read           = seq_read,
1738         .llseek         = seq_lseek,
1739         .release        = single_release,
1740 };
1741
1742 static int emc_table_info_show(struct seq_file *s, void *data)
1743 {
1744         int i;
1745
1746         seq_printf(s, "Table info:\n");
1747         seq_printf(s, "  Rev: 0x%02x\n", tegra_emc_table->rev);
1748         seq_printf(s, "  Table ID: %s\n", tegra_emc_table->table_id);
1749         seq_printf(s, "  Possible rates (kHz):\n");
1750
1751         for (i = 0; i < tegra_emc_table_size; i++) {
1752                 if (tegra_emc_clk_sel[i].input == NULL)
1753                         continue;
1754                 seq_printf(s, "    %lu\n", tegra_emc_table[i].rate);
1755         }
1756
1757         return 0;
1758 }
1759
1760 static int emc_table_info_open(struct inode *inode, struct file *file)
1761 {
1762         return single_open(file, emc_table_info_show, inode->i_private);
1763 }
1764
1765 static const struct file_operations emc_table_info_fops = {
1766         .open           = emc_table_info_open,
1767         .read           = seq_read,
1768         .llseek         = seq_lseek,
1769         .release        = single_release,
1770 };
1771
1772 static int dram_temperature_get(void *data, u64 *val)
1773 {
1774         *val = tegra_emc_get_dram_temperature();
1775         return 0;
1776 }
1777 DEFINE_SIMPLE_ATTRIBUTE(dram_temperature_fops, dram_temperature_get,
1778                         NULL, "%lld\n");
1779
1780 static int over_temp_state_get(void *data, u64 *val)
1781 {
1782         *val = dram_over_temp_state;
1783         return 0;
1784 }
1785 static int over_temp_state_set(void *data, u64 val)
1786 {
1787         return tegra_emc_set_over_temp_state(val);
1788 }
1789 DEFINE_SIMPLE_ATTRIBUTE(over_temp_state_fops, over_temp_state_get,
1790                         over_temp_state_set, "%llu\n");
1791
1792 static int efficiency_get(void *data, u64 *val)
1793 {
1794         *val = tegra_emc_bw_efficiency;
1795         return 0;
1796 }
1797 static int efficiency_set(void *data, u64 val)
1798 {
1799         tegra_emc_bw_efficiency = (val > 100) ? 100 : val;
1800         if (emc)
1801                 tegra_clk_shared_bus_update(emc);
1802
1803         return 0;
1804 }
1805 DEFINE_SIMPLE_ATTRIBUTE(efficiency_fops, efficiency_get,
1806                         efficiency_set, "%llu\n");
1807
1808 static int dsr_get(void *data, u64 *val)
1809 {
1810         *val = tegra_emc_dsr_status();
1811         return 0;
1812 }
1813 DEFINE_SIMPLE_ATTRIBUTE(dsr_fops, dsr_get, NULL, "%llu\n");
1814
1815 static int dsr_override_set(void *data, u64 val)
1816 {
1817         if (val)
1818                 tegra_emc_dsr_override(TEGRA_EMC_DSR_OVERRIDE);
1819         else
1820                 tegra_emc_dsr_override(TEGRA_EMC_DSR_NORMAL);
1821
1822         return 0;
1823 }
1824
1825 static int dsr_override_get(void *data, u64 *val)
1826 {
1827         *val = tegra_emc_dsr_override_status();
1828         return 0;
1829 }
1830 DEFINE_SIMPLE_ATTRIBUTE(dsr_override_fops, dsr_override_get,
1831                         dsr_override_set, "%llu\n");
1832
1833 static int __init tegra_emc_debug_init(void)
1834 {
1835         if (!tegra_emc_table)
1836                 return 0;
1837
1838         emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL);
1839         if (!emc_debugfs_root)
1840                 return -ENOMEM;
1841
1842         if (!debugfs_create_file(
1843                 "stats", S_IRUGO, emc_debugfs_root, NULL, &emc_stats_fops))
1844                 goto err_out;
1845
1846         if (!debugfs_create_u32("clkchange_delay", S_IRUGO | S_IWUSR,
1847                 emc_debugfs_root, (u32 *)&clkchange_delay))
1848                 goto err_out;
1849
1850         if (!debugfs_create_file("dram_temperature", S_IRUGO, emc_debugfs_root,
1851                                  NULL, &dram_temperature_fops))
1852                 goto err_out;
1853
1854         if (!debugfs_create_file("over_temp_state", S_IRUGO | S_IWUSR,
1855                                  emc_debugfs_root, NULL, &over_temp_state_fops))
1856                 goto err_out;
1857
1858         if (!debugfs_create_file("efficiency", S_IRUGO | S_IWUSR,
1859                                  emc_debugfs_root, NULL, &efficiency_fops))
1860                 goto err_out;
1861
1862         if (!debugfs_create_file("dsr", S_IRUGO | S_IWUSR,
1863                                  emc_debugfs_root, NULL, &dsr_fops))
1864                 goto err_out;
1865
1866         if (!debugfs_create_file("dsr_override", S_IRUGO | S_IWUSR,
1867                                  emc_debugfs_root, NULL, &dsr_override_fops))
1868                 goto err_out;
1869
1870         if (!debugfs_create_file("table_info", S_IRUGO | S_IWUSR,
1871                                  emc_debugfs_root, NULL, &emc_table_info_fops))
1872                 goto err_out;
1873
1874         if (tegra_emc_iso_usage_debugfs_init(emc_debugfs_root))
1875                 goto err_out;
1876
1877         return 0;
1878
1879 err_out:
1880         debugfs_remove_recursive(emc_debugfs_root);
1881         return -ENOMEM;
1882 }
1883
1884 late_initcall(tegra_emc_debug_init);
1885 #endif