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