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