ARM: tegra11: clock: Add EMC scaling table initialization
[linux-2.6.git] / arch / arm / mach-tegra / tegra11_emc.c
1 /*
2  * arch/arm/mach-tegra/tegra11_emc.c
3  *
4  * Copyright (C) 2011-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 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
28 #include <asm/cputime.h>
29
30 #include <mach/iomap.h>
31
32 #include "clock.h"
33 #include "dvfs.h"
34 #include "tegra11_emc.h"
35
36 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
37 static bool emc_enable = true;
38 #else
39 static bool emc_enable;
40 #endif
41 module_param(emc_enable, bool, 0644);
42
43 #define PLL_C_DIRECT_FLOOR              333500000
44 #define EMC_STATUS_UPDATE_TIMEOUT       100
45 #define TEGRA_EMC_TABLE_MAX_SIZE        16
46
47
48 #define EMC_CLK_DIV_SHIFT               0
49 #define EMC_CLK_DIV_MAX_VALUE           0xFF
50 #define EMC_CLK_DIV_MASK                (0xFF << EMC_CLK_DIV_SHIFT)
51 #define EMC_CLK_SOURCE_SHIFT            29
52 #define EMC_CLK_SOURCE_MAX_VALUE        3
53 #define EMC_CLK_LOW_JITTER_ENABLE       (0x1 << 31)
54 #define EMC_CLK_MC_SAME_FREQ            (0x1 << 16)
55
56 /* FIXME: actual Tegar11 list */
57 #define BURST_REG_LIST \
58         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_MISC0),
59
60 #if 0
61 #define DEFINE_REG(base, reg) ((base) ? (IO_ADDRESS((base)) + (reg)) : 0)
62 static const void __iomem *burst_reg_addr[TEGRA_EMC_MAX_NUM_REGS] = {
63         BURST_REG_LIST
64 };
65 #undef DEFINE_REG
66 #endif
67
68 #define DEFINE_REG(base, reg)   reg##_INDEX
69 enum {
70         BURST_REG_LIST
71 };
72 #undef DEFINE_REG
73
74 static int emc_num_burst_regs;
75
76 struct emc_sel {
77         struct clk      *input;
78         u32             value;
79         unsigned long   input_rate;
80 };
81 static struct emc_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
82
83 static const struct tegra_emc_table *tegra_emc_table;
84 static int tegra_emc_table_size;
85
86 static u32 dram_dev_num;
87 static u32 dram_type = -1;
88
89 static struct clk *emc;
90
91 static struct {
92         cputime64_t time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE];
93         int last_sel;
94         u64 last_update;
95         u64 clkchange_count;
96         spinlock_t spinlock;
97 } emc_stats;
98
99 /* static DEFINE_SPINLOCK(emc_access_lock); */
100
101 static void __iomem *emc_base = IO_ADDRESS(TEGRA_EMC_BASE);
102 static void __iomem *mc_base = IO_ADDRESS(TEGRA_MC_BASE);
103
104 static inline void emc_writel(u32 val, unsigned long addr)
105 {
106         writel(val, (u32)emc_base + addr);
107 }
108 static inline u32 emc_readl(unsigned long addr)
109 {
110         return readl((u32)emc_base + addr);
111 }
112 static inline void mc_writel(u32 val, unsigned long addr)
113 {
114         writel(val, (u32)mc_base + addr);
115 }
116 static inline u32 mc_readl(unsigned long addr)
117 {
118         return readl((u32)mc_base + addr);
119 }
120
121
122 int tegra_emc_set_rate(unsigned long rate)
123 {
124         /* FIXME: This is just a stub */
125         return 0;
126 }
127
128 long tegra_emc_round_rate(unsigned long rate)
129 {
130         /* FIXME: This is just a stub */
131         return -EINVAL;
132 }
133
134 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
135 {
136         /* FIXME: This is just a stub */
137         return NULL;
138 }
139
140 static int find_matching_input(const struct tegra_emc_table *table,
141                         struct clk *pll_c, struct emc_sel *emc_clk_sel)
142 {
143         u32 div_value = 0;
144         unsigned long input_rate = 0;
145         unsigned long table_rate = table->rate * 1000; /* table rate in kHz */
146         struct clk *src = tegra_get_clock_by_name(table->src_name);
147         const struct clk_mux_sel *sel;
148
149         for (sel = emc->inputs; sel->input != NULL; sel++) {
150                 if (sel->input != src)
151                         continue;
152                 /*
153                  * PLLC is a scalable source. For rates below PLL_C_DIRECT_FLOOR
154                  * configure PLLC at double rate and set 1:2 divider, otherwise
155                  * configure PLLC at target rate with divider 1:1.
156                  */
157                 if (src == pll_c) {
158 #ifdef CONFIG_TEGRA_DUAL_CBUS
159                         if (table_rate < PLL_C_DIRECT_FLOOR) {
160                                 input_rate = 2 * table_rate;
161                                 div_value = 2;
162                         } else {
163                                 input_rate = table_rate;
164                                 div_value = 0;
165                         }
166                         break;
167 #else
168                         continue;       /* pll_c is used for cbus - skip */
169 #endif
170                 }
171
172                 /*
173                  * All other clock sources are fixed rate sources, and must
174                  * run at rate that is an exact multiple of the target.
175                  */
176                 input_rate = clk_get_rate(src);
177
178                 if ((input_rate >= table_rate) &&
179                      (input_rate % table_rate == 0)) {
180                         div_value = 2 * input_rate / table_rate - 2;
181                         break;
182                 }
183         }
184
185         if (!sel->input || (sel->value > EMC_CLK_SOURCE_MAX_VALUE) ||
186             (div_value > EMC_CLK_DIV_MAX_VALUE)) {
187                 pr_warn("tegra: no matching input found for EMC rate %lu\n",
188                         table_rate);
189                 return -EINVAL;
190         }
191
192         emc_clk_sel->input = sel->input;
193         emc_clk_sel->input_rate = input_rate;
194
195         /* Get ready emc clock selection settings for this table rate */
196         emc_clk_sel->value = sel->value << EMC_CLK_SOURCE_SHIFT;
197         emc_clk_sel->value |= (div_value << EMC_CLK_DIV_SHIFT);
198         if ((div_value == 0) && (emc_clk_sel->input == emc->parent))
199                 emc_clk_sel->value |= EMC_CLK_LOW_JITTER_ENABLE;
200
201         if (MC_EMEM_ARB_MISC0_EMC_SAME_FREQ &
202             table->burst_regs[MC_EMEM_ARB_MISC0_INDEX])
203                 emc_clk_sel->value |= EMC_CLK_MC_SAME_FREQ;
204
205         return 0;
206 }
207
208 static void adjust_emc_dvfs_table(const struct tegra_emc_table *table,
209                                   int table_size)
210 {
211         int i, j;
212         unsigned long rate;
213
214         for (i = 0; i < MAX_DVFS_FREQS; i++) {
215                 int mv = emc->dvfs->millivolts[i];
216                 if (!mv)
217                         break;
218
219                 /* For each dvfs voltage find maximum supported rate;
220                    use 1MHz placeholder if not found */
221                 for (rate = 1000, j = 0; j < table_size; j++) {
222                         if (tegra_emc_clk_sel[j].input == NULL)
223                                 continue;       /* invalid entry */
224
225                         if ((mv >= table[j].emc_min_mv) &&
226                             (rate < table[j].rate))
227                                 rate = table[j].rate;
228                 }
229                 /* Table entries specify rate in kHz */
230                 emc->dvfs->freqs[i] = rate * 1000;
231         }
232 }
233
234 void tegra_init_emc(const struct tegra_emc_table *table, int table_size)
235 {
236         int i, mv;
237         u32 reg;
238         bool max_entry = false;
239         unsigned long boot_rate, max_rate;
240         struct clk *pll_c = tegra_get_clock_by_name("pll_c");
241
242         emc_stats.clkchange_count = 0;
243         spin_lock_init(&emc_stats.spinlock);
244         emc_stats.last_update = get_jiffies_64();
245         emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
246
247         boot_rate = clk_get_rate(emc) / 1000;
248         max_rate = clk_get_max_rate(emc) / 1000;
249
250         if ((dram_type != DRAM_TYPE_DDR3) && (dram_type != DRAM_TYPE_LPDDR2)) {
251                 pr_err("tegra: not supported DRAM type %u\n", dram_type);
252                 return;
253         }
254
255         if (emc->parent != tegra_get_clock_by_name("pll_m")) {
256                 pr_err("tegra: boot parent %s is not supported by EMC DFS\n",
257                         emc->parent->name);
258                 return;
259         }
260
261         if (!table || !table_size) {
262                 pr_err("tegra: EMC DFS table is empty\n");
263                 return;
264         }
265
266         tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
267         switch (table[0].rev) {
268         case 0x40:
269                 emc_num_burst_regs = 105; /* FIXME: actual number */
270                 break;
271         default:
272                 pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
273                         table[0].rev);
274                 return;
275         }
276
277         /* Match EMC source/divider settings with table entries */
278         for (i = 0; i < tegra_emc_table_size; i++) {
279                 unsigned long table_rate = table[i].rate;
280
281                 /* Skip "no-rate" entry, or entry violating ascending order */
282                 if (!table_rate ||
283                     (i && (table_rate <= table[i-1].rate)))
284                         continue;
285
286                 BUG_ON(table[i].rev != table[0].rev);
287
288                 if (find_matching_input(&table[i], pll_c,
289                                         &tegra_emc_clk_sel[i]))
290                         continue;
291
292                 if (table_rate == boot_rate)
293                         emc_stats.last_sel = i;
294
295                 if (table_rate == max_rate)
296                         max_entry = true;
297         }
298
299         /* Validate EMC rate and voltage limits */
300         if (!max_entry) {
301                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
302                        " %lu kHz is not found\n", max_rate);
303                 return;
304         }
305
306         tegra_emc_table = table;
307
308         if (emc->dvfs) {
309                 adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
310                 mv = tegra_dvfs_predict_millivolts(emc, max_rate * 1000);
311                 if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
312                         tegra_emc_table = NULL;
313                         pr_err("tegra: invalid EMC DFS table: maximum rate %lu"
314                                " kHz does not match nominal voltage %d\n",
315                                max_rate, emc->dvfs->max_millivolts);
316                         return;
317                 }
318         }
319
320         pr_info("tegra: validated EMC DFS table\n");
321
322         /* Configure clock change mode according to dram type */
323         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
324         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
325                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
326         emc_writel(reg, EMC_CFG_2);
327 }
328
329 void tegra_emc_timing_invalidate(void)
330 {
331         /* FIXME: This is just a stub */
332 }
333
334 void tegra_emc_dram_type_init(struct clk *c)
335 {
336         emc = c;
337
338         dram_type = (emc_readl(EMC_FBIO_CFG5) &
339                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
340
341         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
342 }
343
344 int tegra_emc_get_dram_type(void)
345 {
346         return dram_type;
347 }