ARM: tegra11: clock: Implement EMC set rate operation
[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 #include <linux/debugfs.h>
30 #include <linux/seq_file.h>
31
32 #include <asm/cputime.h>
33
34 #include <mach/iomap.h>
35
36 #include "clock.h"
37 #include "dvfs.h"
38 #include "tegra11_emc.h"
39
40 #ifdef CONFIG_TEGRA_EMC_SCALING_ENABLE
41 static bool emc_enable = true;
42 #else
43 static bool emc_enable;
44 #endif
45 module_param(emc_enable, bool, 0644);
46
47 #define PLL_C_DIRECT_FLOOR              333500000
48 #define EMC_STATUS_UPDATE_TIMEOUT       100
49 #define TEGRA_EMC_TABLE_MAX_SIZE        16
50
51
52 #define EMC_CLK_DIV_SHIFT               0
53 #define EMC_CLK_DIV_MAX_VALUE           0xFF
54 #define EMC_CLK_DIV_MASK                (0xFF << EMC_CLK_DIV_SHIFT)
55 #define EMC_CLK_SOURCE_SHIFT            29
56 #define EMC_CLK_SOURCE_MAX_VALUE        3
57 #define EMC_CLK_LOW_JITTER_ENABLE       (0x1 << 31)
58 #define EMC_CLK_MC_SAME_FREQ            (0x1 << 16)
59
60 /* FIXME: actual Tegar11 list */
61 #define BURST_REG_LIST \
62         DEFINE_REG(TEGRA_EMC_BASE, EMC_RC),                     \
63         DEFINE_REG(TEGRA_EMC_BASE, EMC_RFC),                    \
64         DEFINE_REG(TEGRA_EMC_BASE, EMC_RAS),                    \
65         DEFINE_REG(TEGRA_EMC_BASE, EMC_RP),                     \
66                                                                 \
67         DEFINE_REG(TEGRA_MC_BASE, MC_EMEM_ARB_MISC0),
68
69 #define DEFINE_REG(base, reg) ((base) ? (IO_ADDRESS((base)) + (reg)) : 0)
70 static const void __iomem *burst_reg_addr[TEGRA11_EMC_MAX_NUM_REGS] = {
71         BURST_REG_LIST
72 };
73 #undef DEFINE_REG
74
75 #define DEFINE_REG(base, reg)   reg##_INDEX
76 enum {
77         BURST_REG_LIST
78 };
79 #undef DEFINE_REG
80
81 static int emc_num_burst_regs;
82
83 struct emc_sel {
84         struct clk      *input;
85         u32             value;
86         unsigned long   input_rate;
87 };
88 static struct emc_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
89 static struct tegra11_emc_table start_timing;
90 static const struct tegra11_emc_table *emc_timing;
91
92 static const struct tegra11_emc_table *tegra_emc_table;
93 static int tegra_emc_table_size;
94
95 static u32 dram_dev_num;
96 static u32 dram_type = -1;
97
98 static struct clk *emc;
99
100 static struct {
101         cputime64_t time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE];
102         int last_sel;
103         u64 last_update;
104         u64 clkchange_count;
105         spinlock_t spinlock;
106 } emc_stats;
107
108 static DEFINE_SPINLOCK(emc_access_lock);
109
110 static void __iomem *emc_base = IO_ADDRESS(TEGRA_EMC_BASE);
111 static void __iomem *mc_base = IO_ADDRESS(TEGRA_MC_BASE);
112
113 static inline void emc_writel(u32 val, unsigned long addr)
114 {
115         writel(val, (u32)emc_base + addr);
116 }
117 static inline u32 emc_readl(unsigned long addr)
118 {
119         return readl((u32)emc_base + addr);
120 }
121 static inline void mc_writel(u32 val, unsigned long addr)
122 {
123         writel(val, (u32)mc_base + addr);
124 }
125 static inline u32 mc_readl(unsigned long addr)
126 {
127         return readl((u32)mc_base + addr);
128 }
129
130 static void emc_last_stats_update(int last_sel)
131 {
132         unsigned long flags;
133         u64 cur_jiffies = get_jiffies_64();
134
135         spin_lock_irqsave(&emc_stats.spinlock, flags);
136
137         if (emc_stats.last_sel < TEGRA_EMC_TABLE_MAX_SIZE)
138                 emc_stats.time_at_clock[emc_stats.last_sel] =
139                         emc_stats.time_at_clock[emc_stats.last_sel] +
140                         (cur_jiffies - emc_stats.last_update);
141
142         emc_stats.last_update = cur_jiffies;
143
144         if (last_sel < TEGRA_EMC_TABLE_MAX_SIZE) {
145                 emc_stats.clkchange_count++;
146                 emc_stats.last_sel = last_sel;
147         }
148         spin_unlock_irqrestore(&emc_stats.spinlock, flags);
149 }
150
151 static noinline void emc_set_clock(const struct tegra11_emc_table *next_timing,
152                                    const struct tegra11_emc_table *last_timing,
153                                    u32 clk_setting)
154 {
155         /* FIXME: implement */
156         pr_info("tegra11_emc: Configuring EMC rate %lu (setting: 0x%x)\n",
157                 next_timing->rate, clk_setting);
158 }
159
160 static inline void emc_get_timing(struct tegra11_emc_table *timing)
161 {
162         int i;
163
164         for (i = 0; i < emc_num_burst_regs; i++) {
165                 if (burst_reg_addr[i])
166                         timing->burst_regs[i] = __raw_readl(burst_reg_addr[i]);
167                 else
168                         timing->burst_regs[i] = 0;
169         }
170         timing->emc_acal_interval = 0;
171         timing->emc_zcal_cnt_long = 0;
172         timing->emc_mode_reset = 0;
173         timing->emc_mode_1 = 0;
174         timing->emc_mode_2 = 0;
175         timing->emc_periodic_qrst = (emc_readl(EMC_CFG) &
176                                      EMC_CFG_PERIODIC_QRST) ? 1 : 0;
177         timing->rate = clk_get_rate_locked(emc);
178 }
179
180 /* The EMC registers have shadow registers. When the EMC clock is updated
181  * in the clock controller, the shadow registers are copied to the active
182  * registers, allowing glitchless memory bus frequency changes.
183  * This function updates the shadow registers for a new clock frequency,
184  * and relies on the clock lock on the emc clock to avoid races between
185  * multiple frequency changes. In addition access lock prevents concurrent
186  * access to EMC registers from reading MRR registers */
187 int tegra_emc_set_rate(unsigned long rate)
188 {
189         int i;
190         u32 clk_setting;
191         const struct tegra11_emc_table *last_timing;
192         unsigned long flags;
193
194         if (!tegra_emc_table)
195                 return -EINVAL;
196
197         /* Table entries specify rate in kHz */
198         rate = rate / 1000;
199
200         for (i = 0; i < tegra_emc_table_size; i++) {
201                 if (tegra_emc_clk_sel[i].input == NULL)
202                         continue;       /* invalid entry */
203
204                 if (tegra_emc_table[i].rate == rate)
205                         break;
206         }
207
208         if (i >= tegra_emc_table_size)
209                 return -EINVAL;
210
211         if (!emc_timing) {
212                 /* can not assume that boot timing matches dfs table even
213                    if boot frequency matches one of the table nodes */
214                 emc_get_timing(&start_timing);
215                 last_timing = &start_timing;
216         }
217         else
218                 last_timing = emc_timing;
219
220         clk_setting = tegra_emc_clk_sel[i].value;
221
222         spin_lock_irqsave(&emc_access_lock, flags);
223         emc_set_clock(&tegra_emc_table[i], last_timing, clk_setting);
224         emc_timing = &tegra_emc_table[i];
225         spin_unlock_irqrestore(&emc_access_lock, flags);
226
227         emc_last_stats_update(i);
228
229         pr_debug("%s: rate %lu setting 0x%x\n", __func__, rate, clk_setting);
230
231         return 0;
232 }
233
234 long tegra_emc_round_rate(unsigned long rate)
235 {
236         int i;
237
238         if (!tegra_emc_table)
239                 return clk_get_rate_locked(emc); /* no table - no rate change */
240
241         if (!emc_enable)
242                 return -EINVAL;
243
244         pr_debug("%s: %lu\n", __func__, rate);
245
246         /* Table entries specify rate in kHz */
247         rate = rate / 1000;
248
249         for (i = 0; i < tegra_emc_table_size; i++) {
250                 if (tegra_emc_clk_sel[i].input == NULL)
251                         continue;       /* invalid entry */
252
253                 if (tegra_emc_table[i].rate >= rate) {
254                         pr_debug("%s: using %lu\n",
255                                  __func__, tegra_emc_table[i].rate);
256                         return tegra_emc_table[i].rate * 1000;
257                 }
258         }
259
260         return -EINVAL;
261 }
262
263 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
264 {
265         int i;
266
267         if (!tegra_emc_table) {
268                 if (rate == clk_get_rate_locked(emc)) {
269                         *div_value = emc->div - 2;
270                         return emc->parent;
271                 }
272                 return NULL;
273         }
274
275         pr_debug("%s: %lu\n", __func__, rate);
276
277         /* Table entries specify rate in kHz */
278         rate = rate / 1000;
279
280         for (i = 0; i < tegra_emc_table_size; i++) {
281                 if (tegra_emc_table[i].rate == rate) {
282                         struct clk *p = tegra_emc_clk_sel[i].input;
283
284                         if (p && (tegra_emc_clk_sel[i].input_rate ==
285                                   clk_get_rate(p))) {
286                                 *div_value = (tegra_emc_clk_sel[i].value &
287                                         EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
288                                 return p;
289                         }
290                 }
291         }
292         return NULL;
293 }
294
295 bool tegra_emc_is_parent_ready(unsigned long rate, struct clk **parent,
296                 unsigned long *parent_rate, unsigned long *backup_rate)
297 {
298
299         int i;
300         struct clk *p = NULL;
301         unsigned long p_rate = 0;
302
303         if (!tegra_emc_table || !emc_enable)
304                 return true;
305
306         pr_debug("%s: %lu\n", __func__, rate);
307
308         /* Table entries specify rate in kHz */
309         rate = rate / 1000;
310
311         for (i = 0; i < tegra_emc_table_size; i++) {
312                 if (tegra_emc_table[i].rate == rate) {
313                         p = tegra_emc_clk_sel[i].input;
314                         if (!p)
315                                 continue;       /* invalid entry */
316
317                         p_rate = tegra_emc_clk_sel[i].input_rate;
318                         if (p_rate == clk_get_rate(p))
319                                 return true;
320                         break;
321                 }
322         }
323
324         /* Table match not found - "non existing parent" is ready */
325         if (!p)
326                 return true;
327
328         /*
329          * Table match found, but parent is not ready - continue search
330          * for backup rate: min rate above requested that has different
331          * parent source (since only pll_c is scaled and may not be ready,
332          * any other parent can provide backup)
333          */
334         *parent = p;
335         *parent_rate = p_rate;
336
337         for (i++; i < tegra_emc_table_size; i++) {
338                 p = tegra_emc_clk_sel[i].input;
339                 if (!p)
340                         continue;       /* invalid entry */
341
342                 if (p != (*parent)) {
343                         *backup_rate = tegra_emc_table[i].rate * 1000;
344                         return false;
345                 }
346         }
347
348         /* Parent is not ready, and no backup found */
349         *backup_rate = -EINVAL;
350         return false;
351 }
352
353 static int find_matching_input(const struct tegra11_emc_table *table,
354                         struct clk *pll_c, struct emc_sel *emc_clk_sel)
355 {
356         u32 div_value = 0;
357         unsigned long input_rate = 0;
358         unsigned long table_rate = table->rate * 1000; /* table rate in kHz */
359         struct clk *src = tegra_get_clock_by_name(table->src_name);
360         const struct clk_mux_sel *sel;
361
362         for (sel = emc->inputs; sel->input != NULL; sel++) {
363                 if (sel->input != src)
364                         continue;
365                 /*
366                  * PLLC is a scalable source. For rates below PLL_C_DIRECT_FLOOR
367                  * configure PLLC at double rate and set 1:2 divider, otherwise
368                  * configure PLLC at target rate with divider 1:1.
369                  */
370                 if (src == pll_c) {
371 #ifdef CONFIG_TEGRA_DUAL_CBUS
372                         if (table_rate < PLL_C_DIRECT_FLOOR) {
373                                 input_rate = 2 * table_rate;
374                                 div_value = 2;
375                         } else {
376                                 input_rate = table_rate;
377                                 div_value = 0;
378                         }
379                         break;
380 #else
381                         continue;       /* pll_c is used for cbus - skip */
382 #endif
383                 }
384
385                 /*
386                  * All other clock sources are fixed rate sources, and must
387                  * run at rate that is an exact multiple of the target.
388                  */
389                 input_rate = clk_get_rate(src);
390
391                 if ((input_rate >= table_rate) &&
392                      (input_rate % table_rate == 0)) {
393                         div_value = 2 * input_rate / table_rate - 2;
394                         break;
395                 }
396         }
397
398         if (!sel->input || (sel->value > EMC_CLK_SOURCE_MAX_VALUE) ||
399             (div_value > EMC_CLK_DIV_MAX_VALUE)) {
400                 pr_warn("tegra: no matching input found for EMC rate %lu\n",
401                         table_rate);
402                 return -EINVAL;
403         }
404
405         emc_clk_sel->input = sel->input;
406         emc_clk_sel->input_rate = input_rate;
407
408         /* Get ready emc clock selection settings for this table rate */
409         emc_clk_sel->value = sel->value << EMC_CLK_SOURCE_SHIFT;
410         emc_clk_sel->value |= (div_value << EMC_CLK_DIV_SHIFT);
411         if ((div_value == 0) && (emc_clk_sel->input == emc->parent))
412                 emc_clk_sel->value |= EMC_CLK_LOW_JITTER_ENABLE;
413
414         if (MC_EMEM_ARB_MISC0_EMC_SAME_FREQ &
415             table->burst_regs[MC_EMEM_ARB_MISC0_INDEX])
416                 emc_clk_sel->value |= EMC_CLK_MC_SAME_FREQ;
417
418         return 0;
419 }
420
421 static void adjust_emc_dvfs_table(const struct tegra11_emc_table *table,
422                                   int table_size)
423 {
424         int i, j;
425         unsigned long rate;
426
427         for (i = 0; i < MAX_DVFS_FREQS; i++) {
428                 int mv = emc->dvfs->millivolts[i];
429                 if (!mv)
430                         break;
431
432                 /* For each dvfs voltage find maximum supported rate;
433                    use 1MHz placeholder if not found */
434                 for (rate = 1000, j = 0; j < table_size; j++) {
435                         if (tegra_emc_clk_sel[j].input == NULL)
436                                 continue;       /* invalid entry */
437
438                         if ((mv >= table[j].emc_min_mv) &&
439                             (rate < table[j].rate))
440                                 rate = table[j].rate;
441                 }
442                 /* Table entries specify rate in kHz */
443                 emc->dvfs->freqs[i] = rate * 1000;
444         }
445 }
446
447 static int init_emc_table(const struct tegra11_emc_table *table, int table_size)
448 {
449         int i, mv;
450         u32 reg;
451         bool max_entry = false;
452         unsigned long boot_rate, max_rate;
453         struct clk *pll_c = tegra_get_clock_by_name("pll_c");
454
455         emc_stats.clkchange_count = 0;
456         spin_lock_init(&emc_stats.spinlock);
457         emc_stats.last_update = get_jiffies_64();
458         emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
459
460         boot_rate = clk_get_rate(emc) / 1000;
461         max_rate = clk_get_max_rate(emc) / 1000;
462
463         if ((dram_type != DRAM_TYPE_DDR3) && (dram_type != DRAM_TYPE_LPDDR2)) {
464                 pr_err("tegra: not supported DRAM type %u\n", dram_type);
465                 return -ENODATA;
466         }
467
468         if (emc->parent != tegra_get_clock_by_name("pll_m")) {
469                 pr_err("tegra: boot parent %s is not supported by EMC DFS\n",
470                         emc->parent->name);
471                 return -ENODATA;
472         }
473
474         if (!table || !table_size) {
475                 pr_err("tegra: EMC DFS table is empty\n");
476                 return -ENODATA;
477         }
478
479         tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
480         switch (table[0].rev) {
481         case 0x40:
482                 emc_num_burst_regs = 105; /* FIXME: actual number */
483                 break;
484         default:
485                 pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
486                         table[0].rev);
487                 return -ENODATA;
488         }
489
490         /* Match EMC source/divider settings with table entries */
491         for (i = 0; i < tegra_emc_table_size; i++) {
492                 unsigned long table_rate = table[i].rate;
493
494                 /* Skip "no-rate" entry, or entry violating ascending order */
495                 if (!table_rate ||
496                     (i && (table_rate <= table[i-1].rate)))
497                         continue;
498
499                 BUG_ON(table[i].rev != table[0].rev);
500
501                 if (find_matching_input(&table[i], pll_c,
502                                         &tegra_emc_clk_sel[i]))
503                         continue;
504
505                 if (table_rate == boot_rate)
506                         emc_stats.last_sel = i;
507
508                 if (table_rate == max_rate)
509                         max_entry = true;
510         }
511
512         /* Validate EMC rate and voltage limits */
513         if (!max_entry) {
514                 pr_err("tegra: invalid EMC DFS table: entry for max rate"
515                        " %lu kHz is not found\n", max_rate);
516                 return -ENODATA;
517         }
518
519         tegra_emc_table = table;
520
521         if (emc->dvfs) {
522                 adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
523                 mv = tegra_dvfs_predict_millivolts(emc, max_rate * 1000);
524                 if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
525                         tegra_emc_table = NULL;
526                         pr_err("tegra: invalid EMC DFS table: maximum rate %lu"
527                                " kHz does not match nominal voltage %d\n",
528                                max_rate, emc->dvfs->max_millivolts);
529                         return -ENODATA;
530                 }
531         }
532
533         pr_info("tegra: validated EMC DFS table\n");
534
535         /* Configure clock change mode according to dram type */
536         reg = emc_readl(EMC_CFG_2) & (~EMC_CFG_2_MODE_MASK);
537         reg |= ((dram_type == DRAM_TYPE_LPDDR2) ? EMC_CFG_2_PD_MODE :
538                 EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
539         emc_writel(reg, EMC_CFG_2);
540         return 0;
541 }
542
543 static int __devinit tegra11_emc_probe(struct platform_device *pdev)
544 {
545         struct tegra11_emc_pdata *pdata;
546         struct resource *res;
547
548         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
549         if (!res) {
550                 dev_err(&pdev->dev, "missing register base\n");
551                 return -ENOMEM;
552         }
553
554         pdata = pdev->dev.platform_data;
555         if (!pdata) {
556                 dev_err(&pdev->dev, "missing platform data\n");
557                 return -ENODATA;
558         }
559
560         return init_emc_table(pdata->tables, pdata->num_tables);
561 }
562
563 static struct platform_driver tegra11_emc_driver = {
564         .driver         = {
565                 .name   = "tegra-emc",
566                 .owner  = THIS_MODULE,
567         },
568         .probe          = tegra11_emc_probe,
569 };
570
571 int __init tegra11_emc_init(void)
572 {
573         return platform_driver_register(&tegra11_emc_driver);
574 }
575
576 void tegra_emc_timing_invalidate(void)
577 {
578         emc_timing = NULL;
579 }
580
581 void tegra_emc_dram_type_init(struct clk *c)
582 {
583         emc = c;
584
585         dram_type = (emc_readl(EMC_FBIO_CFG5) &
586                      EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
587
588         dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
589 }
590
591 int tegra_emc_get_dram_type(void)
592 {
593         return dram_type;
594 }
595
596 #ifdef CONFIG_DEBUG_FS
597
598 static struct dentry *emc_debugfs_root;
599
600 static int emc_stats_show(struct seq_file *s, void *data)
601 {
602         int i;
603
604         emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE);
605
606         seq_printf(s, "%-10s %-10s \n", "rate kHz", "time");
607         for (i = 0; i < tegra_emc_table_size; i++) {
608                 if (tegra_emc_clk_sel[i].input == NULL)
609                         continue;       /* invalid entry */
610
611                 seq_printf(s, "%-10lu %-10llu \n", tegra_emc_table[i].rate,
612                            cputime64_to_clock_t(emc_stats.time_at_clock[i]));
613         }
614         seq_printf(s, "%-15s %llu\n", "transitions:",
615                    emc_stats.clkchange_count);
616         seq_printf(s, "%-15s %llu\n", "time-stamp:",
617                    cputime64_to_clock_t(emc_stats.last_update));
618
619         return 0;
620 }
621
622 static int emc_stats_open(struct inode *inode, struct file *file)
623 {
624         return single_open(file, emc_stats_show, inode->i_private);
625 }
626
627 static const struct file_operations emc_stats_fops = {
628         .open           = emc_stats_open,
629         .read           = seq_read,
630         .llseek         = seq_lseek,
631         .release        = single_release,
632 };
633
634 static int __init tegra_emc_debug_init(void)
635 {
636         if (!tegra_emc_table)
637                 return 0;
638
639         emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL);
640         if (!emc_debugfs_root)
641                 return -ENOMEM;
642
643         if (!debugfs_create_file(
644                 "stats", S_IRUGO, emc_debugfs_root, NULL, &emc_stats_fops))
645                 goto err_out;
646
647         return 0;
648
649 err_out:
650         debugfs_remove_recursive(emc_debugfs_root);
651         return -ENOMEM;
652 }
653
654 late_initcall(tegra_emc_debug_init);
655 #endif