06ce3590ad695e49876c9f94fbd65c600c42bc75
[linux-3.10.git] / arch / arm / mach-tegra / pm.c
1 /*
2  * arch/arm/mach-tegra/pm.c
3  *
4  * CPU complex suspend & resume functions for Tegra SoCs
5  *
6  * Copyright (c) 2009-2011, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/ctype.h>
25 #include <linux/init.h>
26 #include <linux/io.h>
27 #include <linux/sched.h>
28 #include <linux/smp.h>
29 #include <linux/irq.h>
30 #include <linux/interrupt.h>
31 #include <linux/clk.h>
32 #include <linux/err.h>
33 #include <linux/debugfs.h>
34 #include <linux/delay.h>
35 #include <linux/suspend.h>
36 #include <linux/slab.h>
37 #include <linux/serial_reg.h>
38 #include <linux/seq_file.h>
39 #include <linux/uaccess.h>
40 #include <linux/syscore_ops.h>
41 #include <linux/cpu_pm.h>
42 #include <linux/clk/tegra.h>
43 #include <linux/export.h>
44 #include <linux/vmalloc.h>
45 #include <linux/memblock.h>
46 #include <linux/console.h>
47
48 #include <asm/cacheflush.h>
49 #include <asm/hardware/cache-l2x0.h>
50 #include <asm/idmap.h>
51 #include <asm/localtimer.h>
52 #include <asm/pgalloc.h>
53 #include <asm/pgtable.h>
54 #include <asm/tlbflush.h>
55
56 #include <mach/irqs.h>
57 #include <mach/powergate.h>
58
59 #include "board.h"
60 #include "clock.h"
61 #include "cpuidle.h"
62 #include "flowctrl.h"
63 #include "fuse.h"
64 #include "gic.h"
65 #include "iomap.h"
66 #include "pm.h"
67 #include "pm-irq.h"
68 #include "reset.h"
69 #include "sleep.h"
70 #include "timer.h"
71 #include "reset.h"
72
73 struct suspend_context {
74         /*
75          * The next 7 values are referenced by offset in __restart_plls
76          * in headsmp-t2.S, and should not be moved
77          */
78         u32 pllx_misc;
79         u32 pllx_base;
80         u32 pllp_misc;
81         u32 pllp_base;
82         u32 pllp_outa;
83         u32 pllp_outb;
84         u32 pll_timeout;
85
86         u32 cpu_burst;
87         u32 clk_csite_src;
88         u32 cclk_divider;
89
90         u32 mc[3];
91         u8 uart[5];
92
93         struct tegra_twd_context twd;
94 };
95
96 #ifdef CONFIG_PM_SLEEP
97 #if USE_TEGRA_CPU_SUSPEND
98 void *tegra_cpu_context;        /* non-cacheable page for CPU context */
99 #endif
100 phys_addr_t tegra_pgd_phys;     /* pgd used by hotplug & LP2 bootup */
101 static pgd_t *tegra_pgd;
102 static DEFINE_SPINLOCK(tegra_lp2_lock);
103 static cpumask_t tegra_in_lp2;
104 static cpumask_t *iram_cpu_lp2_mask;
105 static unsigned long *iram_cpu_lp1_mask;
106 static u8 *iram_save;
107 static unsigned long iram_save_size;
108 static void __iomem *iram_code = IO_ADDRESS(TEGRA_IRAM_CODE_AREA);
109 static void __iomem *clk_rst = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
110 static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);
111 static int tegra_last_pclk;
112 #endif
113
114 struct suspend_context tegra_sctx;
115
116 #define TEGRA_POWER_PWRREQ_POLARITY     (1 << 8)   /* core power request polarity */
117 #define TEGRA_POWER_PWRREQ_OE           (1 << 9)   /* core power request enable */
118 #define TEGRA_POWER_SYSCLK_POLARITY     (1 << 10)  /* sys clk polarity */
119 #define TEGRA_POWER_SYSCLK_OE           (1 << 11)  /* system clock enable */
120 #define TEGRA_POWER_PWRGATE_DIS         (1 << 12)  /* power gate disabled */
121 #define TEGRA_POWER_EFFECT_LP0          (1 << 14)  /* enter LP0 when CPU pwr gated */
122 #define TEGRA_POWER_CPU_PWRREQ_POLARITY (1 << 15)  /* CPU power request polarity */
123 #define TEGRA_POWER_CPU_PWRREQ_OE       (1 << 16)  /* CPU power request enable */
124
125 #define PMC_CTRL                0x0
126 #define PMC_CTRL_LATCH_WAKEUPS  (1 << 5)
127 #define PMC_WAKE_MASK           0xc
128 #define PMC_WAKE_LEVEL          0x10
129 #define PMC_DPAD_ORIDE          0x1C
130 #define PMC_WAKE_DELAY          0xe0
131 #define PMC_DPD_SAMPLE          0x20
132
133 #define PMC_WAKE_STATUS         0x14
134 #define PMC_SW_WAKE_STATUS      0x18
135 #define PMC_COREPWRGOOD_TIMER   0x3c
136 #define PMC_SCRATCH0            0x50
137 #define PMC_SCRATCH1            0x54
138 #define PMC_CPUPWRGOOD_TIMER    0xc8
139 #define PMC_CPUPWROFF_TIMER     0xcc
140 #define PMC_COREPWROFF_TIMER    PMC_WAKE_DELAY
141
142 #define CLK_RESET_CCLK_BURST    0x20
143 #define CLK_RESET_CCLK_DIVIDER  0x24
144 #define CLK_RESET_PLLC_BASE     0x80
145 #define CLK_RESET_PLLM_BASE     0x90
146 #define CLK_RESET_PLLX_BASE     0xe0
147 #define CLK_RESET_PLLX_MISC     0xe4
148 #define CLK_RESET_PLLP_BASE     0xa0
149 #define CLK_RESET_PLLP_OUTA     0xa4
150 #define CLK_RESET_PLLP_OUTB     0xa8
151 #define CLK_RESET_PLLP_MISC     0xac
152
153 #define CLK_RESET_SOURCE_CSITE  0x1d4
154
155 #define CLK_RESET_CCLK_BURST_POLICY_SHIFT 28
156 #define CLK_RESET_CCLK_BURST_POLICY_PLLM   3
157 #define CLK_RESET_CCLK_BURST_POLICY_PLLX   8
158
159 #define EMC_MRW_0               0x0e8
160 #define EMC_MRW_DEV_SELECTN     30
161 #define EMC_MRW_DEV_NONE        (3 << EMC_MRW_DEV_SELECTN)
162
163 #define MC_SECURITY_START       0x6c
164 #define MC_SECURITY_SIZE        0x70
165 #define MC_SECURITY_CFG2        0x7c
166
167 static struct clk *tegra_pclk;
168 static const struct tegra_suspend_platform_data *pdata;
169 static enum tegra_suspend_mode current_suspend_mode = TEGRA_SUSPEND_NONE;
170
171 static const char *tegra_suspend_name[TEGRA_MAX_SUSPEND_MODE] = {
172         [TEGRA_SUSPEND_NONE]    = "none",
173         [TEGRA_SUSPEND_LP2]     = "lp2",
174         [TEGRA_SUSPEND_LP1]     = "lp1",
175         [TEGRA_SUSPEND_LP0]     = "lp0",
176 };
177
178 #if defined(CONFIG_TEGRA_CLUSTER_CONTROL) && INSTRUMENT_CLUSTER_SWITCH
179 enum tegra_cluster_switch_time_id {
180         tegra_cluster_switch_time_id_start = 0,
181         tegra_cluster_switch_time_id_prolog,
182         tegra_cluster_switch_time_id_switch,
183         tegra_cluster_switch_time_id_epilog,
184         tegra_cluster_switch_time_id_max
185 };
186
187 static unsigned long
188                 tegra_cluster_switch_times[tegra_cluster_switch_time_id_max];
189 #define tegra_cluster_switch_time(flags, id) \
190         do { \
191                 barrier(); \
192                 if (flags & TEGRA_POWER_CLUSTER_MASK) { \
193                         void __iomem *timer_us = \
194                                                 IO_ADDRESS(TEGRA_TMRUS_BASE); \
195                         if (id < tegra_cluster_switch_time_id_max) \
196                                 tegra_cluster_switch_times[id] = \
197                                                         readl(timer_us); \
198                                 wmb(); \
199                 } \
200                 barrier(); \
201         } while(0)
202 #else
203 #define tegra_cluster_switch_time(flags, id) do {} while(0)
204 #endif
205
206 #ifdef CONFIG_PM_SLEEP
207 unsigned long tegra_cpu_power_good_time(void)
208 {
209         if (WARN_ON_ONCE(!pdata))
210                 return 5000;
211
212         return pdata->cpu_timer;
213 }
214
215 unsigned long tegra_cpu_power_off_time(void)
216 {
217         if (WARN_ON_ONCE(!pdata))
218                 return 5000;
219
220         return pdata->cpu_off_timer;
221 }
222
223 unsigned long tegra_cpu_lp2_min_residency(void)
224 {
225         if (WARN_ON_ONCE(!pdata))
226                 return 2000;
227
228         return pdata->cpu_lp2_min_residency;
229 }
230
231 /*
232  * create_suspend_pgtable
233  *
234  * Creates a page table with identity mappings of physical memory and IRAM
235  * for use when the MMU is off, in addition to all the regular kernel mappings.
236  */
237 static __init int create_suspend_pgtable(void)
238 {
239         tegra_pgd = pgd_alloc(&init_mm);
240         if (!tegra_pgd)
241                 return -ENOMEM;
242
243         identity_mapping_add(tegra_pgd, phys_to_virt(PHYS_OFFSET),
244                 phys_to_virt(PHYS_OFFSET) + memblock_phys_mem_size(), 0);
245         identity_mapping_add(tegra_pgd, IO_IRAM_VIRT,
246                 IO_IRAM_VIRT + SECTION_SIZE, 0);
247
248         /* inner/outer write-back/write-allocate, sharable */
249         tegra_pgd_phys = (virt_to_phys(tegra_pgd) & PAGE_MASK) | 0x4A;
250
251         return 0;
252 }
253
254 /*
255  * alloc_suspend_context
256  *
257  * Allocate a non-cacheable page to hold the CPU contexts.
258  * The standard ARM CPU context save functions don't work if there's
259  * an external L2 cache controller (like a PL310) in system.
260  */
261 static __init int alloc_suspend_context(void)
262 {
263 #if USE_TEGRA_CPU_SUSPEND
264         pgprot_t prot = __pgprot_modify(pgprot_kernel, L_PTE_MT_MASK,
265                                         L_PTE_MT_BUFFERABLE | L_PTE_XN);
266         struct page *ctx_page;
267         unsigned long ctx_virt = 0;
268         pgd_t *pgd;
269         pmd_t *pmd;
270         pte_t *pte;
271
272         ctx_page = alloc_pages(GFP_KERNEL, 0);
273         if (IS_ERR_OR_NULL(ctx_page))
274                 goto fail;
275
276         tegra_cpu_context = vm_map_ram(&ctx_page, 1, -1, prot);
277         if (IS_ERR_OR_NULL(tegra_cpu_context))
278                 goto fail;
279
280         /* Add the context page to our private pgd. */
281         ctx_virt = (unsigned long)tegra_cpu_context;
282
283         pgd = tegra_pgd + pgd_index(ctx_virt);
284         if (!pgd_present(*pgd))
285                 goto fail;
286         pmd = pmd_offset(pgd, ctx_virt);
287         if (!pmd_none(*pmd))
288                 goto fail;
289         pte = pte_alloc_kernel(pmd, ctx_virt);
290         if (!pte)
291                 goto fail;
292
293         set_pte_ext(pte, mk_pte(ctx_page, prot), 0);
294
295         outer_clean_range(__pa(pmd), __pa(pmd + 1));
296
297         return 0;
298
299 fail:
300         if (ctx_page)
301                 __free_page(ctx_page);
302         if (ctx_virt)
303                 vm_unmap_ram((void*)ctx_virt, 1);
304         tegra_cpu_context = NULL;
305         return -ENOMEM;
306 #else
307         return 0;
308 #endif
309 }
310
311 /* ensures that sufficient time is passed for a register write to
312  * serialize into the 32KHz domain */
313 static void pmc_32kwritel(u32 val, unsigned long offs)
314 {
315         writel(val, pmc + offs);
316         udelay(130);
317 }
318
319 static void set_power_timers(unsigned long us_on, unsigned long us_off,
320                              long rate)
321 {
322         static unsigned long last_us_off = 0;
323         unsigned long long ticks;
324         unsigned long long pclk;
325
326         if (WARN_ON_ONCE(rate <= 0))
327                 pclk = 100000000;
328         else
329                 pclk = rate;
330
331         if ((rate != tegra_last_pclk) || (us_off != last_us_off)) {
332                 ticks = (us_on * pclk) + 999999ull;
333                 do_div(ticks, 1000000);
334                 writel((unsigned long)ticks, pmc + PMC_CPUPWRGOOD_TIMER);
335
336                 ticks = (us_off * pclk) + 999999ull;
337                 do_div(ticks, 1000000);
338                 writel((unsigned long)ticks, pmc + PMC_CPUPWROFF_TIMER);
339                 wmb();
340         }
341         tegra_last_pclk = pclk;
342         last_us_off = us_off;
343 }
344
345 /*
346  * restore_cpu_complex
347  *
348  * restores cpu clock setting, clears flow controller
349  *
350  * Always called on CPU 0.
351  */
352 static void restore_cpu_complex(u32 mode)
353 {
354         int cpu = smp_processor_id();
355         unsigned int reg;
356
357         BUG_ON(cpu != 0);
358
359         /* restore original PLL settings */
360         writel(tegra_sctx.pllx_misc, clk_rst + CLK_RESET_PLLX_MISC);
361         writel(tegra_sctx.pllx_base, clk_rst + CLK_RESET_PLLX_BASE);
362         writel(tegra_sctx.pllp_misc, clk_rst + CLK_RESET_PLLP_MISC);
363         writel(tegra_sctx.pllp_base, clk_rst + CLK_RESET_PLLP_BASE);
364         writel(tegra_sctx.pllp_outa, clk_rst + CLK_RESET_PLLP_OUTA);
365         writel(tegra_sctx.pllp_outb, clk_rst + CLK_RESET_PLLP_OUTB);
366
367         /* Is CPU complex already running on PLLX? */
368         reg = readl(clk_rst + CLK_RESET_CCLK_BURST);
369         reg &= 0xF;
370         if (reg != 0x8) {
371                 /* restore original burst policy setting; PLLX state restored
372                  * by CPU boot-up code - wait for PLL stabilization if PLLX
373                  * was enabled */
374
375                 reg = readl(clk_rst + CLK_RESET_PLLX_BASE);
376                 /* mask out bit 27 - not to check PLL lock bit */
377                 BUG_ON((reg & (~(1 << 27))) !=
378                                 (tegra_sctx.pllx_base & (~(1 << 27))));
379
380                 if (tegra_sctx.pllx_base & (1<<30)) {
381 #if USE_PLL_LOCK_BITS
382                         /* Enable lock detector */
383                         reg = readl(clk_rst + CLK_RESET_PLLX_MISC);
384                         reg |= 1<<18;
385                         writel(reg, clk_rst + CLK_RESET_PLLX_MISC);
386                         while (!(readl(clk_rst + CLK_RESET_PLLX_BASE) &&
387                                  (1<<27)))
388                                 cpu_relax();
389 #else
390                         udelay(300);
391 #endif
392                 }
393                 writel(tegra_sctx.cclk_divider, clk_rst +
394                        CLK_RESET_CCLK_DIVIDER);
395                 writel(tegra_sctx.cpu_burst, clk_rst +
396                        CLK_RESET_CCLK_BURST);
397         }
398
399         writel(tegra_sctx.clk_csite_src, clk_rst + CLK_RESET_SOURCE_CSITE);
400
401         /* Do not power-gate CPU 0 when flow controlled */
402         reg = flowctrl_read_cpu_csr(cpu);
403         reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
404         reg &= ~FLOW_CTRL_CSR_WFI_BITMAP;       /* clear wfi bitmap */
405         reg &= ~FLOW_CTRL_CSR_ENABLE;           /* clear enable */
406         reg |= FLOW_CTRL_CSR_INTR_FLAG;         /* clear intr */
407         reg |= FLOW_CTRL_CSR_EVENT_FLAG;        /* clear event */
408         flowctrl_write_cpu_csr(cpu, reg);
409
410         /* If an immedidate cluster switch is being perfomed, restore the
411            local timer registers. See save_cpu_complex() for the details. */
412         if (mode & (TEGRA_POWER_CLUSTER_MASK | TEGRA_POWER_CLUSTER_IMMEDIATE))
413                 tegra_twd_resume(&tegra_sctx.twd);
414 }
415
416 /*
417  * suspend_cpu_complex
418  *
419  * saves pll state for use by restart_plls, prepares flow controller for
420  * transition to suspend state
421  *
422  * Must always be called on cpu 0.
423  */
424 static void suspend_cpu_complex(u32 mode)
425 {
426         int cpu = smp_processor_id();
427         unsigned int reg;
428         int i;
429
430         BUG_ON(cpu != 0);
431
432         /* switch coresite to clk_m, save off original source */
433         tegra_sctx.clk_csite_src = readl(clk_rst + CLK_RESET_SOURCE_CSITE);
434         writel(3<<30, clk_rst + CLK_RESET_SOURCE_CSITE);
435
436         tegra_sctx.cpu_burst = readl(clk_rst + CLK_RESET_CCLK_BURST);
437         tegra_sctx.pllx_base = readl(clk_rst + CLK_RESET_PLLX_BASE);
438         tegra_sctx.pllx_misc = readl(clk_rst + CLK_RESET_PLLX_MISC);
439         tegra_sctx.pllp_base = readl(clk_rst + CLK_RESET_PLLP_BASE);
440         tegra_sctx.pllp_outa = readl(clk_rst + CLK_RESET_PLLP_OUTA);
441         tegra_sctx.pllp_outb = readl(clk_rst + CLK_RESET_PLLP_OUTB);
442         tegra_sctx.pllp_misc = readl(clk_rst + CLK_RESET_PLLP_MISC);
443         tegra_sctx.cclk_divider = readl(clk_rst + CLK_RESET_CCLK_DIVIDER);
444
445         /* If an immedidate cluster switch is being perfomed, save the
446            local timer registers. For calls resulting from CPU LP2 in
447            idle or system suspend, the local timer is shut down and
448            timekeeping switches over to the global system timer. */
449         if (mode & (TEGRA_POWER_CLUSTER_MASK | TEGRA_POWER_CLUSTER_IMMEDIATE))
450                 tegra_twd_suspend(&tegra_sctx.twd);
451
452         reg = flowctrl_read_cpu_csr(cpu);
453         reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
454         reg &= ~FLOW_CTRL_CSR_WFI_BITMAP;       /* clear wfi bitmap */
455         reg |= FLOW_CTRL_CSR_INTR_FLAG;         /* clear intr flag */
456         reg |= FLOW_CTRL_CSR_EVENT_FLAG;        /* clear event flag */
457 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
458         reg |= FLOW_CTRL_CSR_WFE_CPU0 << cpu;   /* enable power gating on wfe */
459 #else
460         reg |= FLOW_CTRL_CSR_WFI_CPU0 << cpu;   /* enable power gating on wfi */
461 #endif
462         reg |= FLOW_CTRL_CSR_ENABLE;            /* enable power gating */
463         flowctrl_write_cpu_csr(cpu, reg);
464
465         for (i = 0; i < num_possible_cpus(); i++) {
466                 if (i == cpu)
467                         continue;
468                 reg = flowctrl_read_cpu_csr(i);
469                 reg |= FLOW_CTRL_CSR_EVENT_FLAG;
470                 reg |= FLOW_CTRL_CSR_INTR_FLAG;
471                 flowctrl_write_cpu_csr(i, reg);
472         }
473
474         tegra_gic_cpu_disable();
475 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
476         /* Tegra3 enters LPx states via WFI - do not propagate legacy IRQs
477            to CPU core to avoid fall through WFI (IRQ-to-flow controller wake
478            path is not affected). */
479         tegra_gic_pass_through_disable();
480 #endif
481 }
482
483 void tegra_clear_cpu_in_lp2(int cpu)
484 {
485         spin_lock(&tegra_lp2_lock);
486         BUG_ON(!cpumask_test_cpu(cpu, &tegra_in_lp2));
487         cpumask_clear_cpu(cpu, &tegra_in_lp2);
488
489         /* Update the IRAM copy used by the reset handler. The IRAM copy
490            can't use used directly by cpumask_clear_cpu() because it uses
491            LDREX/STREX which requires the addressed location to be inner
492            cacheable and sharable which IRAM isn't. */
493         writel(tegra_in_lp2.bits[0], iram_cpu_lp2_mask);
494         dsb();
495
496         spin_unlock(&tegra_lp2_lock);
497 }
498
499 bool tegra_set_cpu_in_lp2(int cpu)
500 {
501         bool last_cpu = false;
502
503         spin_lock(&tegra_lp2_lock);
504         BUG_ON(cpumask_test_cpu(cpu, &tegra_in_lp2));
505         cpumask_set_cpu(cpu, &tegra_in_lp2);
506
507         /* Update the IRAM copy used by the reset handler. The IRAM copy
508            can't use used directly by cpumask_set_cpu() because it uses
509            LDREX/STREX which requires the addressed location to be inner
510            cacheable and sharable which IRAM isn't. */
511         writel(tegra_in_lp2.bits[0], iram_cpu_lp2_mask);
512         dsb();
513
514         if ((cpu == 0) && cpumask_equal(&tegra_in_lp2, cpu_online_mask))
515                 last_cpu = true;
516 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
517         else
518                 tegra2_cpu_set_resettable_soon();
519 #endif
520
521         spin_unlock(&tegra_lp2_lock);
522         return last_cpu;
523 }
524
525 unsigned int tegra_idle_lp2_last(unsigned int sleep_time, unsigned int flags)
526 {
527         u32 mode;       /* hardware + software power mode flags */
528         unsigned int remain;
529
530         /* Only the last cpu down does the final suspend steps */
531         mode = readl(pmc + PMC_CTRL);
532         mode |= TEGRA_POWER_CPU_PWRREQ_OE;
533         mode |= TEGRA_POWER_PWRREQ_OE;
534         mode &= ~TEGRA_POWER_EFFECT_LP0;
535         pmc_32kwritel(mode, PMC_CTRL);
536         mode |= flags;
537
538         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_start);
539
540         /*
541          * We can use clk_get_rate_all_locked() here, because all other cpus
542          * are in LP2 state and irqs are disabled
543          */
544         if (flags & TEGRA_POWER_CLUSTER_MASK) {
545                 set_power_timers(pdata->cpu_timer, 0,
546                         clk_get_rate_all_locked(tegra_pclk));
547                 tegra_cluster_switch_prolog(mode);
548         } else {
549                 set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer,
550                         clk_get_rate_all_locked(tegra_pclk));
551         }
552
553         if (sleep_time)
554                 tegra_lp2_set_trigger(sleep_time);
555
556         cpu_cluster_pm_enter();
557         suspend_cpu_complex(mode);
558         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_prolog);
559         flush_cache_all();
560         outer_flush_all();
561         outer_disable();
562
563         tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
564
565 #ifdef CONFIG_CACHE_L2X0
566         l2x0_enable();
567 #endif
568         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_switch);
569         restore_cpu_complex(mode);
570         cpu_cluster_pm_exit();
571
572         remain = tegra_lp2_timer_remain();
573         if (sleep_time)
574                 tegra_lp2_set_trigger(0);
575
576         if (flags & TEGRA_POWER_CLUSTER_MASK)
577                 tegra_cluster_switch_epilog(mode);
578
579         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_epilog);
580
581 #if INSTRUMENT_CLUSTER_SWITCH
582         if (flags & TEGRA_POWER_CLUSTER_MASK) {
583                 pr_err("%s: prolog %lu us, switch %lu us, epilog %lu us, total %lu us\n",
584                         is_lp_cluster() ? "G=>LP" : "LP=>G",
585                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_prolog] -
586                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_start],
587                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_switch] -
588                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_prolog],
589                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_epilog] -
590                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_switch],
591                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_epilog] -
592                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_start]);
593         }
594 #endif
595         return remain;
596 }
597
598 static int tegra_common_suspend(void)
599 {
600         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
601
602         tegra_sctx.mc[0] = readl(mc + MC_SECURITY_START);
603         tegra_sctx.mc[1] = readl(mc + MC_SECURITY_SIZE);
604         tegra_sctx.mc[2] = readl(mc + MC_SECURITY_CFG2);
605
606         /* copy the reset vector and SDRAM shutdown code into IRAM */
607         memcpy(iram_save, iram_code, iram_save_size);
608         memcpy(iram_code, tegra_iram_start(), iram_save_size);
609
610         return 0;
611 }
612
613 static void tegra_common_resume(void)
614 {
615         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
616 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
617         void __iomem *emc = IO_ADDRESS(TEGRA_EMC_BASE);
618 #endif
619
620         /* Clear DPD sample */
621         writel(0x0, pmc + PMC_DPD_SAMPLE);
622
623         writel(tegra_sctx.mc[0], mc + MC_SECURITY_START);
624         writel(tegra_sctx.mc[1], mc + MC_SECURITY_SIZE);
625         writel(tegra_sctx.mc[2], mc + MC_SECURITY_CFG2);
626 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
627         /* trigger emc mode write */
628         writel(EMC_MRW_DEV_NONE, emc + EMC_MRW_0);
629 #endif
630         /* clear scratch registers shared by suspend and the reset pen */
631         writel(0x0, pmc + PMC_SCRATCH39);
632         writel(0x0, pmc + PMC_SCRATCH41);
633
634         /* restore IRAM */
635         memcpy(iram_code, iram_save, iram_save_size);
636 }
637
638 static int tegra_suspend_prepare_late(void)
639 {
640 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
641         disable_irq(INT_SYS_STATS_MON);
642 #endif
643         return 0;
644 }
645
646 static void tegra_suspend_wake(void)
647 {
648 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
649         enable_irq(INT_SYS_STATS_MON);
650 #endif
651 }
652
653 static void tegra_pm_set(enum tegra_suspend_mode mode)
654 {
655         u32 reg, boot_flag;
656         unsigned long rate = 32768;
657
658         reg = readl(pmc + PMC_CTRL);
659         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
660         reg |= TEGRA_POWER_PWRREQ_OE;
661         reg &= ~TEGRA_POWER_EFFECT_LP0;
662
663         switch (mode) {
664         case TEGRA_SUSPEND_LP0:
665                 /*
666                  * LP0 boots through the AVP, which then resumes the AVP to
667                  * the address in scratch 39, and the cpu to the address in
668                  * scratch 41 to tegra_resume
669                  */
670                 writel(0x0, pmc + PMC_SCRATCH39);
671
672                 /* Enable DPD sample to trigger sampling pads data and direction
673                  * in which pad will be driven during lp0 mode*/
674                 writel(0x1, pmc + PMC_DPD_SAMPLE);
675
676                 /* Set warmboot flag */
677                 boot_flag = readl(pmc + PMC_SCRATCH0);
678                 pmc_32kwritel(boot_flag | 1, PMC_SCRATCH0);
679
680                 pmc_32kwritel(tegra_lp0_vec_start, PMC_SCRATCH1);
681
682                 reg |= TEGRA_POWER_EFFECT_LP0;
683                 /* No break here. LP0 code falls through to write SCRATCH41 */
684         case TEGRA_SUSPEND_LP1:
685                 __raw_writel(virt_to_phys(tegra_resume), pmc + PMC_SCRATCH41);
686                 wmb();
687                 break;
688         case TEGRA_SUSPEND_LP2:
689                 rate = clk_get_rate(tegra_pclk);
690                 break;
691         case TEGRA_SUSPEND_NONE:
692                 return;
693         default:
694                 BUG();
695         }
696
697         set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer, rate);
698
699         pmc_32kwritel(reg, PMC_CTRL);
700 }
701
702 static const char *lp_state[TEGRA_MAX_SUSPEND_MODE] = {
703         [TEGRA_SUSPEND_NONE] = "none",
704         [TEGRA_SUSPEND_LP2] = "LP2",
705         [TEGRA_SUSPEND_LP1] = "LP1",
706         [TEGRA_SUSPEND_LP0] = "LP0",
707 };
708
709 static int tegra_suspend_enter(suspend_state_t state)
710 {
711         int ret;
712
713         if (pdata && pdata->board_suspend)
714                 pdata->board_suspend(current_suspend_mode, TEGRA_SUSPEND_BEFORE_PERIPHERAL);
715
716         ret = tegra_suspend_dram(current_suspend_mode, 0);
717
718         if (pdata && pdata->board_resume)
719                 pdata->board_resume(current_suspend_mode, TEGRA_RESUME_AFTER_PERIPHERAL);
720
721         return ret;
722 }
723
724 static void tegra_suspend_check_pwr_stats(void)
725 {
726         /* cpus and l2 are powered off later */
727         unsigned long pwrgate_partid_mask =
728 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC)
729                 (1 << TEGRA_POWERGATE_HEG)      |
730                 (1 << TEGRA_POWERGATE_SATA)     |
731                 (1 << TEGRA_POWERGATE_3D1)      |
732 #endif
733                 (1 << TEGRA_POWERGATE_3D)       |
734                 (1 << TEGRA_POWERGATE_VENC)     |
735                 (1 << TEGRA_POWERGATE_PCIE)     |
736                 (1 << TEGRA_POWERGATE_VDEC)     |
737                 (1 << TEGRA_POWERGATE_MPE);
738
739         int partid;
740
741         for_each_set_bit(partid, &pwrgate_partid_mask, BITS_PER_LONG)
742                 if (tegra_powergate_is_powered(partid) == 1)
743                         pr_warning("partition %s is left on before suspend\n",
744                                 tegra_powergate_get_name(partid));
745
746         return;
747 }
748
749 int tegra_suspend_dram(enum tegra_suspend_mode mode, unsigned int flags)
750 {
751         BUG_ON(mode < 0 || mode >= TEGRA_MAX_SUSPEND_MODE);
752
753         if ((mode == TEGRA_SUSPEND_LP0) && !tegra_pm_irq_lp0_allowed()) {
754                 pr_info("LP0 not used due to unsupported wakeup events\n");
755                 mode = TEGRA_SUSPEND_LP1;
756         }
757
758         if ((mode == TEGRA_SUSPEND_LP0) || (mode == TEGRA_SUSPEND_LP1))
759                 tegra_suspend_check_pwr_stats();
760
761         tegra_common_suspend();
762
763         pr_info("Entering suspend state %s\n", lp_state[mode]);
764
765         tegra_pm_set(mode);
766
767         if (flags & TEGRA_POWER_CLUSTER_MASK)
768                 tegra_cluster_switch_prolog(flags);
769
770         if (pdata && pdata->board_suspend)
771                 pdata->board_suspend(mode, TEGRA_SUSPEND_BEFORE_CPU);
772
773         local_fiq_disable();
774
775         cpu_pm_enter();
776         cpu_cluster_pm_enter();
777
778         if (mode == TEGRA_SUSPEND_LP0) {
779                 tegra_lp0_cpu_mode(true);
780                 tegra_lp0_suspend_mc();
781         }
782
783         suspend_cpu_complex(flags);
784
785         if (mode == TEGRA_SUSPEND_LP1)
786                 *iram_cpu_lp1_mask = 1;
787
788         flush_cache_all();
789         outer_flush_all();
790         outer_disable();
791
792         if (mode == TEGRA_SUSPEND_LP2)
793                 tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
794         else
795                 tegra_sleep_core(PHYS_OFFSET - PAGE_OFFSET);
796
797         tegra_init_cache();
798
799         if (mode == TEGRA_SUSPEND_LP0) {
800                 tegra_lp0_resume_mc();
801                 tegra_lp0_cpu_mode(false);
802         } else if (mode == TEGRA_SUSPEND_LP1)
803                 *iram_cpu_lp1_mask = 0;
804
805         restore_cpu_complex(flags);
806
807         cpu_cluster_pm_exit();
808         cpu_pm_exit();
809
810         if (pdata && pdata->board_resume)
811                 pdata->board_resume(mode, TEGRA_RESUME_AFTER_CPU);
812
813         local_fiq_enable();
814
815         tegra_common_resume();
816
817         if (flags & TEGRA_POWER_CLUSTER_MASK)
818                 tegra_cluster_switch_epilog(mode);
819
820         pr_info("Exited suspend state %s\n", lp_state[mode]);
821
822         return 0;
823 }
824
825 /*
826  * Function pointers to optional board specific function
827  */
828 void (*tegra_deep_sleep)(int);
829 EXPORT_SYMBOL(tegra_deep_sleep);
830
831 static int tegra_suspend_prepare(void)
832 {
833         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
834                 tegra_deep_sleep(1);
835         return 0;
836 }
837
838 static void tegra_suspend_finish(void)
839 {
840         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
841                 tegra_deep_sleep(0);
842 }
843
844 static const struct platform_suspend_ops tegra_suspend_ops = {
845         .valid          = suspend_valid_only_mem,
846         .prepare        = tegra_suspend_prepare,
847         .finish         = tegra_suspend_finish,
848         .prepare_late   = tegra_suspend_prepare_late,
849         .wake           = tegra_suspend_wake,
850         .enter          = tegra_suspend_enter,
851 };
852
853 static ssize_t suspend_mode_show(struct kobject *kobj,
854                                         struct kobj_attribute *attr, char *buf)
855 {
856         char *start = buf;
857         char *end = buf + PAGE_SIZE;
858
859         start += scnprintf(start, end - start, "%s ", \
860                                 tegra_suspend_name[current_suspend_mode]);
861         start += scnprintf(start, end - start, "\n");
862
863         return start - buf;
864 }
865
866 static ssize_t suspend_mode_store(struct kobject *kobj,
867                                         struct kobj_attribute *attr,
868                                         const char *buf, size_t n)
869 {
870         int len;
871         const char *name_ptr;
872         enum tegra_suspend_mode new_mode;
873
874         name_ptr = buf;
875         while (*name_ptr && !isspace(*name_ptr))
876                 name_ptr++;
877         len = name_ptr - buf;
878         if (!len)
879                 goto bad_name;
880
881         for (new_mode = TEGRA_SUSPEND_NONE; \
882                         new_mode < TEGRA_MAX_SUSPEND_MODE; ++new_mode) {
883                 if (!strncmp(buf, tegra_suspend_name[new_mode], len)) {
884                         current_suspend_mode = new_mode;
885                         break;
886                 }
887         }
888
889 bad_name:
890         return n;
891 }
892
893 static struct kobj_attribute suspend_mode_attribute =
894         __ATTR(mode, 0644, suspend_mode_show, suspend_mode_store);
895
896 static struct kobject *suspend_kobj;
897 #endif
898
899 void __init tegra_init_suspend(struct tegra_suspend_platform_data *plat)
900 {
901         u32 reg;
902         u32 mode;
903
904         tegra_pclk = clk_get_sys(NULL, "pclk");
905         BUG_ON(IS_ERR(tegra_pclk));
906         pdata = plat;
907         (void)reg;
908         (void)mode;
909
910 #ifndef CONFIG_PM_SLEEP
911         if (plat->suspend_mode != TEGRA_SUSPEND_NONE) {
912                 pr_warning("%s: Suspend requires CONFIG_PM_SLEEP -- "
913                            "disabling suspend\n", __func__);
914                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
915         }
916 #else
917         if (create_suspend_pgtable() < 0) {
918                 pr_err("%s: PGD memory alloc failed -- LP0/LP1/LP2 unavailable\n",
919                                 __func__);
920                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
921                 goto fail;
922         }
923
924         if (alloc_suspend_context() < 0) {
925                 pr_err("%s: CPU context alloc failed -- LP0/LP1/LP2 unavailable\n",
926                                 __func__);
927                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
928                 goto fail;
929         }
930
931         if ((tegra_chip_id == TEGRA30) &&
932             (tegra_revision == TEGRA_REVISION_A01) &&
933             (plat->suspend_mode == TEGRA_SUSPEND_LP0)) {
934                 /* Tegra 3 A01 supports only LP1 */
935                 pr_warning("%s: Suspend mode LP0 is not supported on A01 "
936                            "-- disabling LP0\n", __func__);
937                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
938         }
939         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && tegra_lp0_vec_size &&
940                 tegra_lp0_vec_relocate) {
941                 unsigned char *reloc_lp0;
942                 unsigned long tmp;
943                 void __iomem *orig;
944                 reloc_lp0 = kmalloc(tegra_lp0_vec_size + L1_CACHE_BYTES - 1,
945                                         GFP_KERNEL);
946                 WARN_ON(!reloc_lp0);
947                 if (!reloc_lp0) {
948                         pr_err("%s: Failed to allocate reloc_lp0\n",
949                                 __func__);
950                         goto out;
951                 }
952
953                 orig = ioremap(tegra_lp0_vec_start, tegra_lp0_vec_size);
954                 WARN_ON(!orig);
955                 if (!orig) {
956                         pr_err("%s: Failed to map tegra_lp0_vec_start %08lx\n",
957                                 __func__, tegra_lp0_vec_start);
958                         kfree(reloc_lp0);
959                         goto out;
960                 }
961
962                 tmp = (unsigned long) reloc_lp0;
963                 tmp = (tmp + L1_CACHE_BYTES - 1) & ~(L1_CACHE_BYTES - 1);
964                 reloc_lp0 = (unsigned char *)tmp;
965                 memcpy(reloc_lp0, orig, tegra_lp0_vec_size);
966                 iounmap(orig);
967                 tegra_lp0_vec_start = virt_to_phys(reloc_lp0);
968         }
969
970 out:
971         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && !tegra_lp0_vec_size) {
972                 pr_warning("%s: Suspend mode LP0 requested, no lp0_vec "
973                            "provided by bootlader -- disabling LP0\n",
974                            __func__);
975                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
976         }
977
978         iram_save_size = tegra_iram_end() - tegra_iram_start();
979
980         iram_save = kmalloc(iram_save_size, GFP_KERNEL);
981         if (!iram_save && (plat->suspend_mode >= TEGRA_SUSPEND_LP1)) {
982                 pr_err("%s: unable to allocate memory for SDRAM self-refresh "
983                        "-- LP0/LP1 unavailable\n", __func__);
984                 plat->suspend_mode = TEGRA_SUSPEND_LP2;
985         }
986
987         /* !!!FIXME!!! THIS IS TEGRA2 ONLY */
988         /* Initialize scratch registers used for CPU LP2 synchronization */
989         writel(0, pmc + PMC_SCRATCH37);
990         writel(0, pmc + PMC_SCRATCH38);
991         writel(0, pmc + PMC_SCRATCH39);
992         writel(0, pmc + PMC_SCRATCH41);
993
994         /* Always enable CPU power request; just normal polarity is supported */
995         reg = readl(pmc + PMC_CTRL);
996         BUG_ON(reg & TEGRA_POWER_CPU_PWRREQ_POLARITY);
997         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
998         pmc_32kwritel(reg, PMC_CTRL);
999
1000         /* Configure core power request and system clock control if LP0
1001            is supported */
1002         __raw_writel(pdata->core_timer, pmc + PMC_COREPWRGOOD_TIMER);
1003         __raw_writel(pdata->core_off_timer, pmc + PMC_COREPWROFF_TIMER);
1004
1005         reg = readl(pmc + PMC_CTRL);
1006
1007         if (!pdata->sysclkreq_high)
1008                 reg |= TEGRA_POWER_SYSCLK_POLARITY;
1009         else
1010                 reg &= ~TEGRA_POWER_SYSCLK_POLARITY;
1011
1012         if (!pdata->corereq_high)
1013                 reg |= TEGRA_POWER_PWRREQ_POLARITY;
1014         else
1015                 reg &= ~TEGRA_POWER_PWRREQ_POLARITY;
1016
1017         /* configure output inverters while the request is tristated */
1018         pmc_32kwritel(reg, PMC_CTRL);
1019
1020         /* now enable requests */
1021         reg |= TEGRA_POWER_SYSCLK_OE;
1022         reg |= TEGRA_POWER_PWRREQ_OE;
1023         pmc_32kwritel(reg, PMC_CTRL);
1024
1025         if (pdata->suspend_mode == TEGRA_SUSPEND_LP0)
1026                 tegra_lp0_suspend_init();
1027
1028         suspend_set_ops(&tegra_suspend_ops);
1029
1030         /* Create /sys/power/suspend/type */
1031         suspend_kobj = kobject_create_and_add("suspend", power_kobj);
1032         if (suspend_kobj) {
1033                 if (sysfs_create_file(suspend_kobj, \
1034                                                 &suspend_mode_attribute.attr))
1035                         pr_err("%s: sysfs_create_file suspend type failed!\n",
1036                                                                 __func__);
1037         }
1038
1039         iram_cpu_lp2_mask = tegra_cpu_lp2_mask;
1040         iram_cpu_lp1_mask = tegra_cpu_lp1_mask;
1041 fail:
1042 #endif
1043         if (plat->suspend_mode == TEGRA_SUSPEND_NONE)
1044                 tegra_lp2_in_idle(false);
1045
1046         current_suspend_mode = plat->suspend_mode;
1047 }
1048
1049 unsigned long debug_uart_port_base = 0;
1050 EXPORT_SYMBOL(debug_uart_port_base);
1051
1052 static int tegra_debug_uart_suspend(void)
1053 {
1054         void __iomem *uart;
1055         u32 lcr;
1056
1057         if (!debug_uart_port_base)
1058                 return 0;
1059
1060         uart = IO_ADDRESS(debug_uart_port_base);
1061
1062         lcr = readb(uart + UART_LCR * 4);
1063
1064         tegra_sctx.uart[0] = lcr;
1065         tegra_sctx.uart[1] = readb(uart + UART_MCR * 4);
1066
1067         /* DLAB = 0 */
1068         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1069
1070         tegra_sctx.uart[2] = readb(uart + UART_IER * 4);
1071
1072         /* DLAB = 1 */
1073         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1074
1075         tegra_sctx.uart[3] = readb(uart + UART_DLL * 4);
1076         tegra_sctx.uart[4] = readb(uart + UART_DLM * 4);
1077
1078         writeb(lcr, uart + UART_LCR * 4);
1079
1080         return 0;
1081 }
1082
1083 static void tegra_debug_uart_resume(void)
1084 {
1085         void __iomem *uart;
1086         u32 lcr;
1087
1088         if (!debug_uart_port_base)
1089                 return;
1090
1091         uart = IO_ADDRESS(debug_uart_port_base);
1092
1093         lcr = tegra_sctx.uart[0];
1094
1095         writeb(tegra_sctx.uart[1], uart + UART_MCR * 4);
1096
1097         /* DLAB = 0 */
1098         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1099
1100         writeb(tegra_sctx.uart[2], uart + UART_IER * 4);
1101
1102         /* DLAB = 1 */
1103         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1104
1105         writeb(tegra_sctx.uart[3], uart + UART_DLL * 4);
1106         writeb(tegra_sctx.uart[4], uart + UART_DLM * 4);
1107
1108         writeb(lcr, uart + UART_LCR * 4);
1109 }
1110
1111 static struct syscore_ops tegra_debug_uart_syscore_ops = {
1112         .suspend = tegra_debug_uart_suspend,
1113         .resume = tegra_debug_uart_resume,
1114 };
1115
1116 struct clk *debug_uart_clk = NULL;
1117 EXPORT_SYMBOL(debug_uart_clk);
1118
1119 void tegra_console_uart_suspend(void)
1120 {
1121         if (console_suspend_enabled && debug_uart_clk)
1122                 clk_disable(debug_uart_clk);
1123 }
1124
1125 void tegra_console_uart_resume(void)
1126 {
1127         if (console_suspend_enabled && debug_uart_clk)
1128                 clk_enable(debug_uart_clk);
1129 }
1130
1131 static int tegra_debug_uart_syscore_init(void)
1132 {
1133         register_syscore_ops(&tegra_debug_uart_syscore_ops);
1134         return 0;
1135 }
1136 arch_initcall(tegra_debug_uart_syscore_init);
1137
1138 #ifdef CONFIG_DEBUG_FS
1139 static int tegra_suspend_debug_show(struct seq_file *s, void *data)
1140 {
1141         seq_printf(s, "%s\n", tegra_suspend_name[*(int *)s->private]);
1142         return 0;
1143 }
1144
1145 static int tegra_suspend_debug_open(struct inode *inode, struct file *file)
1146 {
1147         return single_open(file, tegra_suspend_debug_show, inode->i_private);
1148 }
1149
1150 static int tegra_suspend_debug_write(struct file *file,
1151         const char __user *user_buf, size_t count, loff_t *ppos)
1152 {
1153         char buf[32];
1154         int buf_size;
1155         int i;
1156         struct seq_file *s = file->private_data;
1157         enum tegra_suspend_mode *val = s->private;
1158
1159         memset(buf, 0x00, sizeof(buf));
1160         buf_size = min(count, (sizeof(buf)-1));
1161         if (copy_from_user(buf, user_buf, buf_size))
1162                 return -EFAULT;
1163
1164         for (i = 0; i < TEGRA_MAX_SUSPEND_MODE; i++) {
1165                 if (!strnicmp(buf, tegra_suspend_name[i],
1166                     strlen(tegra_suspend_name[i]))) {
1167                         if (i > pdata->suspend_mode)
1168                                 return -EINVAL;
1169                         *val = i;
1170                         return count;
1171                 }
1172         }
1173
1174         return -EINVAL;
1175 }
1176
1177 static const struct file_operations tegra_suspend_debug_fops = {
1178         .open           = tegra_suspend_debug_open,
1179         .write          = tegra_suspend_debug_write,
1180         .read           = seq_read,
1181         .llseek         = seq_lseek,
1182         .release        = single_release,
1183 };
1184
1185 static int __init tegra_suspend_debug_init(void)
1186 {
1187         struct dentry *d;
1188
1189         d = debugfs_create_file("suspend_mode", 0755, NULL,
1190                 (void *)&current_suspend_mode, &tegra_suspend_debug_fops);
1191         if (!d) {
1192                 pr_info("Failed to create suspend_mode debug file\n");
1193                 return -ENOMEM;
1194         }
1195
1196         return 0;
1197 }
1198
1199 late_initcall(tegra_suspend_debug_init);
1200 #endif