0224e54702a41423778cc31acdd97c1e2537467e
[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 #include <linux/platform_device.h>
28 #include <linux/platform_data/tegra_emc.h>
29
30 #include <asm/cputime.h>
31
32 #include <mach/iomap.h>
33
34 #include "clock.h"
35 #include "dvfs.h"
36 #include "tegra11_emc.h"
37
38 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
39 static bool emc_enable = true;
40 #else
41 static bool emc_enable;
42 #endif
43 module_param(emc_enable, bool, 0644);
44
45 #define PLL_C_DIRECT_FLOOR              333500000
46 #define EMC_STATUS_UPDATE_TIMEOUT       100
47 #define TEGRA_EMC_TABLE_MAX_SIZE        16
48
49
50 #define EMC_CLK_DIV_SHIFT               0
51 #define EMC_CLK_DIV_MAX_VALUE           0xFF
52 #define EMC_CLK_DIV_MASK                (0xFF << EMC_CLK_DIV_SHIFT)
53 #define EMC_CLK_SOURCE_SHIFT            29
54 #define EMC_CLK_SOURCE_MAX_VALUE        3
55 #define EMC_CLK_LOW_JITTER_ENABLE       (0x1 << 31)
56 #define EMC_CLK_MC_SAME_FREQ            (0x1 << 16)
57
58 /* FIXME: actual Tegar11 list */
59 #define BURST_REG_LIST \
60         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_MISC0),
61
62 #if 0
63 #define DEFINE_REG(base, reg) ((base) ? (IO_ADDRESS((base)) + (reg)) : 0)
64 static const void __iomem *burst_reg_addr[TEGRA_EMC_MAX_NUM_REGS] = {
65         BURST_REG_LIST
66 };
67 #undef DEFINE_REG
68 #endif
69
70 #define DEFINE_REG(base, reg)   reg##_INDEX
71 enum {
72         BURST_REG_LIST
73 };
74 #undef DEFINE_REG
75
76 static int emc_num_burst_regs;
77
78 struct emc_sel {
79         struct clk      *input;
80         u32             value;
81         unsigned long   input_rate;
82 };
83 static struct emc_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
84
85 static const struct tegra11_emc_table *tegra_emc_table;
86 static int tegra_emc_table_size;
87
88 static u32 dram_dev_num;
89 static u32 dram_type = -1;
90
91 static struct clk *emc;
92
93 static struct {
94         cputime64_t time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE];
95         int last_sel;
96         u64 last_update;
97         u64 clkchange_count;
98         spinlock_t spinlock;
99 } emc_stats;
100
101 /* static DEFINE_SPINLOCK(emc_access_lock); */
102
103 static void __iomem *emc_base = IO_ADDRESS(TEGRA_EMC_BASE);
104 static void __iomem *mc_base = IO_ADDRESS(TEGRA_MC_BASE);
105
106 static inline void emc_writel(u32 val, unsigned long addr)
107 {
108         writel(val, (u32)emc_base + addr);
109 }
110 static inline u32 emc_readl(unsigned long addr)
111 {
112         return readl((u32)emc_base + addr);
113 }
114 static inline void mc_writel(u32 val, unsigned long addr)
115 {
116         writel(val, (u32)mc_base + addr);
117 }
118 static inline u32 mc_readl(unsigned long addr)
119 {
120         return readl((u32)mc_base + addr);
121 }
122
123
124 int tegra_emc_set_rate(unsigned long rate)
125 {
126         /* FIXME: This is just a stub */
127         return 0;
128 }
129
130 long tegra_emc_round_rate(unsigned long rate)
131 {
132         int i;
133
134         if (!tegra_emc_table)
135                 return clk_get_rate_locked(emc); /* no table - no rate change */
136
137         if (!emc_enable)
138                 return -EINVAL;
139
140         pr_debug("%s: %lu\n", __func__, rate);
141
142         /* Table entries specify rate in kHz */
143         rate = rate / 1000;
144
145         for (i = 0; i < tegra_emc_table_size; i++) {
146                 if (tegra_emc_clk_sel[i].input == NULL)
147                         continue;       /* invalid entry */
148
149                 if (tegra_emc_table[i].rate >= rate) {
150                         pr_debug("%s: using %lu\n",
151                                  __func__, tegra_emc_table[i].rate);
152                         return tegra_emc_table[i].rate * 1000;
153                 }
154         }
155
156         return -EINVAL;
157 }
158
159 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
160 {
161         int i;
162
163         if (!tegra_emc_table) {
164                 if (rate == clk_get_rate_locked(emc)) {
165                         *div_value = emc->div - 2;
166                         return emc->parent;
167                 }
168                 return NULL;
169         }
170
171         pr_debug("%s: %lu\n", __func__, rate);
172
173         /* Table entries specify rate in kHz */
174         rate = rate / 1000;
175
176         for (i = 0; i < tegra_emc_table_size; i++) {
177                 if (tegra_emc_table[i].rate == rate) {
178                         struct clk *p = tegra_emc_clk_sel[i].input;
179
180                         if (p && (tegra_emc_clk_sel[i].input_rate ==
181                                   clk_get_rate(p))) {
182                                 *div_value = (tegra_emc_clk_sel[i].value &
183                                         EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
184                                 return p;
185                         }
186                 }
187         }
188         return NULL;
189 }
190
191 bool tegra_emc_is_parent_ready(unsigned long rate, struct clk **parent,
192                 unsigned long *parent_rate, unsigned long *backup_rate)
193 {
194
195         int i;
196         struct clk *p = NULL;
197         unsigned long p_rate = 0;
198
199         if (!tegra_emc_table || !emc_enable)
200                 return true;
201
202         pr_debug("%s: %lu\n", __func__, rate);
203
204         /* Table entries specify rate in kHz */
205         rate = rate / 1000;
206
207         for (i = 0; i < tegra_emc_table_size; i++) {
208                 if (tegra_emc_table[i].rate == rate) {
209                         p = tegra_emc_clk_sel[i].input;
210                         if (!p)
211                                 continue;       /* invalid entry */
212
213                         p_rate = tegra_emc_clk_sel[i].input_rate;
214                         if (p_rate == clk_get_rate(p))
215                                 return true;
216                         break;
217                 }
218         }
219
220         /* Table match not found - "non existing parent" is ready */
221         if (!p)
222                 return true;
223
224         /*
225          * Table match found, but parent is not ready - continue search
226          * for backup rate: min rate above requested that has different
227          * parent source (since only pll_c is scaled and may not be ready,
228          * any other parent can provide backup)
229          */
230         *parent = p;
231         *parent_rate = p_rate;
232
233         for (i++; i < tegra_emc_table_size; i++) {
234                 p = tegra_emc_clk_sel[i].input;
235                 if (!p)
236                         continue;       /* invalid entry */
237
238                 if (p != (*parent)) {
239                         *backup_rate = tegra_emc_table[i].rate * 1000;
240                         return false;
241                 }
242         }
243
244         /* Parent is not ready, and no backup found */
245         *backup_rate = -EINVAL;
246         return false;
247 }
248
249 static int find_matching_input(const struct tegra11_emc_table *table,
250                         struct clk *pll_c, struct emc_sel *emc_clk_sel)
251 {
252         u32 div_value = 0;
253         unsigned long input_rate = 0;
254         unsigned long table_rate = table->rate * 1000; /* table rate in kHz */
255         struct clk *src = tegra_get_clock_by_name(table->src_name);
256         const struct clk_mux_sel *sel;
257
258         for (sel = emc->inputs; sel->input != NULL; sel++) {
259                 if (sel->input != src)
260                         continue;
261                 /*
262                  * PLLC is a scalable source. For rates below PLL_C_DIRECT_FLOOR
263                  * configure PLLC at double rate and set 1:2 divider, otherwise
264                  * configure PLLC at target rate with divider 1:1.
265                  */
266                 if (src == pll_c) {
267 #ifdef CONFIG_TEGRA_DUAL_CBUS
268                         if (table_rate < PLL_C_DIRECT_FLOOR) {
269                                 input_rate = 2 * table_rate;
270                                 div_value = 2;
271                         } else {
272                                 input_rate = table_rate;
273                                 div_value = 0;
274                         }
275                         break;
276 #else
277                         continue;       /* pll_c is used for cbus - skip */
278 #endif
279                 }
280
281                 /*
282                  * All other clock sources are fixed rate sources, and must
283                  * run at rate that is an exact multiple of the target.
284                  */
285                 input_rate = clk_get_rate(src);
286
287                 if ((input_rate >= table_rate) &&
288                      (input_rate % table_rate == 0)) {
289                         div_value = 2 * input_rate / table_rate - 2;
290                         break;
291                 }
292         }
293
294         if (!sel->input || (sel->value > EMC_CLK_SOURCE_MAX_VALUE) ||
295             (div_value > EMC_CLK_DIV_MAX_VALUE)) {
296                 pr_warn("tegra: no matching input found for EMC rate %lu\n",
297                         table_rate);
298                 return -EINVAL;
299         }
300
301         emc_clk_sel->input = sel->input;
302         emc_clk_sel->input_rate = input_rate;
303
304         /* Get ready emc clock selection settings for this table rate */
305         emc_clk_sel->value = sel->value << EMC_CLK_SOURCE_SHIFT;
306         emc_clk_sel->value |= (div_value << EMC_CLK_DIV_SHIFT);
307         if ((div_value == 0) && (emc_clk_sel->input == emc->parent))
308                 emc_clk_sel->value |= EMC_CLK_LOW_JITTER_ENABLE;
309
310         if (MC_EMEM_ARB_MISC0_EMC_SAME_FREQ &
311             table->burst_regs[MC_EMEM_ARB_MISC0_INDEX])
312                 emc_clk_sel->value |= EMC_CLK_MC_SAME_FREQ;
313
314         return 0;
315 }
316
317 static void adjust_emc_dvfs_table(const struct tegra11_emc_table *table,
318                                   int table_size)
319 {
320         int i, j;
321         unsigned long rate;
322
323         for (i = 0; i < MAX_DVFS_FREQS; i++) {
324                 int mv = emc->dvfs->millivolts[i];
325                 if (!mv)
326                         break;
327
328                 /* For each dvfs voltage find maximum supported rate;
329                    use 1MHz placeholder if not found */
330                 for (rate = 1000, j = 0; j < table_size; j++) {
331                         if (tegra_emc_clk_sel[j].input == NULL)
332                                 continue;       /* invalid entry */
333
334                         if ((mv >= table[j].emc_min_mv) &&
335                             (rate < table[j].rate))
336                                 rate = table[j].rate;
337                 }
338                 /* Table entries specify rate in kHz */
339                 emc->dvfs->freqs[i] = rate * 1000;
340         }
341 }
342
343 static int init_emc_table(const struct tegra11_emc_table *table, int table_size)
344 {
345         int i, mv;
346         u32 reg;
347         bool max_entry = false;
348         unsigned long boot_rate, max_rate;
349         struct clk *pll_c = tegra_get_clock_by_name("pll_c");
350
351         emc_stats.clkchange_count = 0;
352         spin_lock_init(&emc_stats.spinlock);
353         emc_stats.last_update = get_jiffies_64();
354         emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
355
356         boot_rate = clk_get_rate(emc) / 1000;
357         max_rate = clk_get_max_rate(emc) / 1000;
358
359         if ((dram_type != DRAM_TYPE_DDR3) && (dram_type != DRAM_TYPE_LPDDR2)) {
360                 pr_err("tegra: not supported DRAM type %u\n", dram_type);
361                 return -ENODATA;
362         }
363
364         if (emc->parent != tegra_get_clock_by_name("pll_m")) {
365                 pr_err("tegra: boot parent %s is not supported by EMC DFS\n",
366                         emc->parent->name);
367                 return -ENODATA;
368         }
369
370         if (!table || !table_size) {
371                 pr_err("tegra: EMC DFS table is empty\n");
372                 return -ENODATA;
373         }
374
375         tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
376         switch (table[0].rev) {
377         case 0x40:
378                 emc_num_burst_regs = 105; /* FIXME: actual number */
379                 break;
380         default:
381                 pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
382                         table[0].rev);
383                 return -ENODATA;
384         }
385
386         /* Match EMC source/divider settings with table entries */
387         for (i = 0; i < tegra_emc_table_size; i++) {
388                 unsigned long table_rate = table[i].rate;
389
390                 /* Skip "no-rate" entry, or entry violating ascending order */
391                 if (!table_rate ||
392                     (i && (table_rate <= table[i-1].rate)))
393                         continue;
394
395                 BUG_ON(table[i].rev != table[0].rev);
396
397                 if (find_matching_input(&table[i], pll_c,
398                                         &tegra_emc_clk_sel[i]))
399                         continue;
400
401                 if (table_rate == boot_rate)
402                         emc_stats.last_sel = i;
403
404                 if (table_rate == max_rate)
405                         max_entry = true;
406         }
407
408         /* Validate EMC rate and voltage limits */
409         if (!max_entry) {
410                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
411                        " %lu kHz is not found\n", max_rate);
412                 return -ENODATA;
413         }
414
415         tegra_emc_table = table;
416
417         if (emc->dvfs) {
418                 adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
419                 mv = tegra_dvfs_predict_millivolts(emc, max_rate * 1000);
420                 if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
421                         tegra_emc_table = NULL;
422                         pr_err("tegra: invalid EMC DFS table: maximum rate %lu"
423                                " kHz does not match nominal voltage %d\n",
424                                max_rate, emc->dvfs->max_millivolts);
425                         return -ENODATA;
426                 }
427         }
428
429         pr_info("tegra: validated EMC DFS table\n");
430
431         /* Configure clock change mode according to dram type */
432         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
433         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
434                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
435         emc_writel(reg, EMC_CFG_2);
436         return 0;
437 }
438
439 static int __devinit tegra11_emc_probe(struct platform_device *pdev)
440 {
441         struct tegra11_emc_pdata *pdata;
442         struct resource *res;
443
444         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
445         if (!res) {
446                 dev_err(&pdev->dev, "missing register base\n");
447                 return -ENOMEM;
448         }
449
450         pdata = pdev->dev.platform_data;
451         if (!pdata) {
452                 dev_err(&pdev->dev, "missing platform data\n");
453                 return -ENODATA;
454         }
455
456         return init_emc_table(pdata->tables, pdata->num_tables);
457 }
458
459 static struct platform_driver tegra11_emc_driver = {
460         .driver         = {
461                 .name   = "tegra-emc",
462                 .owner  = THIS_MODULE,
463         },
464         .probe          = tegra11_emc_probe,
465 };
466
467 int __init tegra11_emc_init(void)
468 {
469         return platform_driver_register(&tegra11_emc_driver);
470 }
471
472 void tegra_emc_timing_invalidate(void)
473 {
474         /* FIXME: This is just a stub */
475 }
476
477 void tegra_emc_dram_type_init(struct clk *c)
478 {
479         emc = c;
480
481         dram_type = (emc_readl(EMC_FBIO_CFG5) &
482                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
483
484         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
485 }
486
487 int tegra_emc_get_dram_type(void)
488 {
489         return dram_type;
490 }