ARM: tegra: power: restore reset handler after lp0
[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                 tegra_cpu_reset_handler_save();
782         }
783
784         suspend_cpu_complex(flags);
785
786         if (mode == TEGRA_SUSPEND_LP1)
787                 *iram_cpu_lp1_mask = 1;
788
789         flush_cache_all();
790         outer_flush_all();
791         outer_disable();
792
793         if (mode == TEGRA_SUSPEND_LP2)
794                 tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
795         else
796                 tegra_sleep_core(PHYS_OFFSET - PAGE_OFFSET);
797
798         tegra_init_cache();
799
800         if (mode == TEGRA_SUSPEND_LP0) {
801                 tegra_cpu_reset_handler_restore();
802                 tegra_lp0_resume_mc();
803                 tegra_lp0_cpu_mode(false);
804         } else if (mode == TEGRA_SUSPEND_LP1)
805                 *iram_cpu_lp1_mask = 0;
806
807         restore_cpu_complex(flags);
808
809         cpu_cluster_pm_exit();
810         cpu_pm_exit();
811
812         if (pdata && pdata->board_resume)
813                 pdata->board_resume(mode, TEGRA_RESUME_AFTER_CPU);
814
815         local_fiq_enable();
816
817         tegra_common_resume();
818
819         if (flags & TEGRA_POWER_CLUSTER_MASK)
820                 tegra_cluster_switch_epilog(mode);
821
822         pr_info("Exited suspend state %s\n", lp_state[mode]);
823
824         return 0;
825 }
826
827 /*
828  * Function pointers to optional board specific function
829  */
830 void (*tegra_deep_sleep)(int);
831 EXPORT_SYMBOL(tegra_deep_sleep);
832
833 static int tegra_suspend_prepare(void)
834 {
835         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
836                 tegra_deep_sleep(1);
837         return 0;
838 }
839
840 static void tegra_suspend_finish(void)
841 {
842         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
843                 tegra_deep_sleep(0);
844 }
845
846 static const struct platform_suspend_ops tegra_suspend_ops = {
847         .valid          = suspend_valid_only_mem,
848         .prepare        = tegra_suspend_prepare,
849         .finish         = tegra_suspend_finish,
850         .prepare_late   = tegra_suspend_prepare_late,
851         .wake           = tegra_suspend_wake,
852         .enter          = tegra_suspend_enter,
853 };
854
855 static ssize_t suspend_mode_show(struct kobject *kobj,
856                                         struct kobj_attribute *attr, char *buf)
857 {
858         char *start = buf;
859         char *end = buf + PAGE_SIZE;
860
861         start += scnprintf(start, end - start, "%s ", \
862                                 tegra_suspend_name[current_suspend_mode]);
863         start += scnprintf(start, end - start, "\n");
864
865         return start - buf;
866 }
867
868 static ssize_t suspend_mode_store(struct kobject *kobj,
869                                         struct kobj_attribute *attr,
870                                         const char *buf, size_t n)
871 {
872         int len;
873         const char *name_ptr;
874         enum tegra_suspend_mode new_mode;
875
876         name_ptr = buf;
877         while (*name_ptr && !isspace(*name_ptr))
878                 name_ptr++;
879         len = name_ptr - buf;
880         if (!len)
881                 goto bad_name;
882
883         for (new_mode = TEGRA_SUSPEND_NONE; \
884                         new_mode < TEGRA_MAX_SUSPEND_MODE; ++new_mode) {
885                 if (!strncmp(buf, tegra_suspend_name[new_mode], len)) {
886                         current_suspend_mode = new_mode;
887                         break;
888                 }
889         }
890
891 bad_name:
892         return n;
893 }
894
895 static struct kobj_attribute suspend_mode_attribute =
896         __ATTR(mode, 0644, suspend_mode_show, suspend_mode_store);
897
898 static struct kobject *suspend_kobj;
899 #endif
900
901 void __init tegra_init_suspend(struct tegra_suspend_platform_data *plat)
902 {
903         u32 reg;
904         u32 mode;
905
906         tegra_pclk = clk_get_sys(NULL, "pclk");
907         BUG_ON(IS_ERR(tegra_pclk));
908         pdata = plat;
909         (void)reg;
910         (void)mode;
911
912 #ifndef CONFIG_PM_SLEEP
913         if (plat->suspend_mode != TEGRA_SUSPEND_NONE) {
914                 pr_warning("%s: Suspend requires CONFIG_PM_SLEEP -- "
915                            "disabling suspend\n", __func__);
916                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
917         }
918 #else
919         if (create_suspend_pgtable() < 0) {
920                 pr_err("%s: PGD memory alloc failed -- LP0/LP1/LP2 unavailable\n",
921                                 __func__);
922                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
923                 goto fail;
924         }
925
926         if (alloc_suspend_context() < 0) {
927                 pr_err("%s: CPU context alloc failed -- LP0/LP1/LP2 unavailable\n",
928                                 __func__);
929                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
930                 goto fail;
931         }
932
933         if ((tegra_chip_id == TEGRA30) &&
934             (tegra_revision == TEGRA_REVISION_A01) &&
935             (plat->suspend_mode == TEGRA_SUSPEND_LP0)) {
936                 /* Tegra 3 A01 supports only LP1 */
937                 pr_warning("%s: Suspend mode LP0 is not supported on A01 "
938                            "-- disabling LP0\n", __func__);
939                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
940         }
941         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && tegra_lp0_vec_size &&
942                 tegra_lp0_vec_relocate) {
943                 unsigned char *reloc_lp0;
944                 unsigned long tmp;
945                 void __iomem *orig;
946                 reloc_lp0 = kmalloc(tegra_lp0_vec_size + L1_CACHE_BYTES - 1,
947                                         GFP_KERNEL);
948                 WARN_ON(!reloc_lp0);
949                 if (!reloc_lp0) {
950                         pr_err("%s: Failed to allocate reloc_lp0\n",
951                                 __func__);
952                         goto out;
953                 }
954
955                 orig = ioremap(tegra_lp0_vec_start, tegra_lp0_vec_size);
956                 WARN_ON(!orig);
957                 if (!orig) {
958                         pr_err("%s: Failed to map tegra_lp0_vec_start %08lx\n",
959                                 __func__, tegra_lp0_vec_start);
960                         kfree(reloc_lp0);
961                         goto out;
962                 }
963
964                 tmp = (unsigned long) reloc_lp0;
965                 tmp = (tmp + L1_CACHE_BYTES - 1) & ~(L1_CACHE_BYTES - 1);
966                 reloc_lp0 = (unsigned char *)tmp;
967                 memcpy(reloc_lp0, orig, tegra_lp0_vec_size);
968                 iounmap(orig);
969                 tegra_lp0_vec_start = virt_to_phys(reloc_lp0);
970         }
971
972 out:
973         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && !tegra_lp0_vec_size) {
974                 pr_warning("%s: Suspend mode LP0 requested, no lp0_vec "
975                            "provided by bootlader -- disabling LP0\n",
976                            __func__);
977                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
978         }
979
980         iram_save_size = tegra_iram_end() - tegra_iram_start();
981
982         iram_save = kmalloc(iram_save_size, GFP_KERNEL);
983         if (!iram_save && (plat->suspend_mode >= TEGRA_SUSPEND_LP1)) {
984                 pr_err("%s: unable to allocate memory for SDRAM self-refresh "
985                        "-- LP0/LP1 unavailable\n", __func__);
986                 plat->suspend_mode = TEGRA_SUSPEND_LP2;
987         }
988
989         /* !!!FIXME!!! THIS IS TEGRA2 ONLY */
990         /* Initialize scratch registers used for CPU LP2 synchronization */
991         writel(0, pmc + PMC_SCRATCH37);
992         writel(0, pmc + PMC_SCRATCH38);
993         writel(0, pmc + PMC_SCRATCH39);
994         writel(0, pmc + PMC_SCRATCH41);
995
996         /* Always enable CPU power request; just normal polarity is supported */
997         reg = readl(pmc + PMC_CTRL);
998         BUG_ON(reg & TEGRA_POWER_CPU_PWRREQ_POLARITY);
999         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
1000         pmc_32kwritel(reg, PMC_CTRL);
1001
1002         /* Configure core power request and system clock control if LP0
1003            is supported */
1004         __raw_writel(pdata->core_timer, pmc + PMC_COREPWRGOOD_TIMER);
1005         __raw_writel(pdata->core_off_timer, pmc + PMC_COREPWROFF_TIMER);
1006
1007         reg = readl(pmc + PMC_CTRL);
1008
1009         if (!pdata->sysclkreq_high)
1010                 reg |= TEGRA_POWER_SYSCLK_POLARITY;
1011         else
1012                 reg &= ~TEGRA_POWER_SYSCLK_POLARITY;
1013
1014         if (!pdata->corereq_high)
1015                 reg |= TEGRA_POWER_PWRREQ_POLARITY;
1016         else
1017                 reg &= ~TEGRA_POWER_PWRREQ_POLARITY;
1018
1019         /* configure output inverters while the request is tristated */
1020         pmc_32kwritel(reg, PMC_CTRL);
1021
1022         /* now enable requests */
1023         reg |= TEGRA_POWER_SYSCLK_OE;
1024         reg |= TEGRA_POWER_PWRREQ_OE;
1025         pmc_32kwritel(reg, PMC_CTRL);
1026
1027         if (pdata->suspend_mode == TEGRA_SUSPEND_LP0)
1028                 tegra_lp0_suspend_init();
1029
1030         suspend_set_ops(&tegra_suspend_ops);
1031
1032         /* Create /sys/power/suspend/type */
1033         suspend_kobj = kobject_create_and_add("suspend", power_kobj);
1034         if (suspend_kobj) {
1035                 if (sysfs_create_file(suspend_kobj, \
1036                                                 &suspend_mode_attribute.attr))
1037                         pr_err("%s: sysfs_create_file suspend type failed!\n",
1038                                                                 __func__);
1039         }
1040
1041         iram_cpu_lp2_mask = tegra_cpu_lp2_mask;
1042         iram_cpu_lp1_mask = tegra_cpu_lp1_mask;
1043 fail:
1044 #endif
1045         if (plat->suspend_mode == TEGRA_SUSPEND_NONE)
1046                 tegra_lp2_in_idle(false);
1047
1048         current_suspend_mode = plat->suspend_mode;
1049 }
1050
1051 unsigned long debug_uart_port_base = 0;
1052 EXPORT_SYMBOL(debug_uart_port_base);
1053
1054 static int tegra_debug_uart_suspend(void)
1055 {
1056         void __iomem *uart;
1057         u32 lcr;
1058
1059         if (!debug_uart_port_base)
1060                 return 0;
1061
1062         uart = IO_ADDRESS(debug_uart_port_base);
1063
1064         lcr = readb(uart + UART_LCR * 4);
1065
1066         tegra_sctx.uart[0] = lcr;
1067         tegra_sctx.uart[1] = readb(uart + UART_MCR * 4);
1068
1069         /* DLAB = 0 */
1070         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1071
1072         tegra_sctx.uart[2] = readb(uart + UART_IER * 4);
1073
1074         /* DLAB = 1 */
1075         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1076
1077         tegra_sctx.uart[3] = readb(uart + UART_DLL * 4);
1078         tegra_sctx.uart[4] = readb(uart + UART_DLM * 4);
1079
1080         writeb(lcr, uart + UART_LCR * 4);
1081
1082         return 0;
1083 }
1084
1085 static void tegra_debug_uart_resume(void)
1086 {
1087         void __iomem *uart;
1088         u32 lcr;
1089
1090         if (!debug_uart_port_base)
1091                 return;
1092
1093         uart = IO_ADDRESS(debug_uart_port_base);
1094
1095         lcr = tegra_sctx.uart[0];
1096
1097         writeb(tegra_sctx.uart[1], uart + UART_MCR * 4);
1098
1099         /* DLAB = 0 */
1100         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1101
1102         writeb(tegra_sctx.uart[2], uart + UART_IER * 4);
1103
1104         /* DLAB = 1 */
1105         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1106
1107         writeb(tegra_sctx.uart[3], uart + UART_DLL * 4);
1108         writeb(tegra_sctx.uart[4], uart + UART_DLM * 4);
1109
1110         writeb(lcr, uart + UART_LCR * 4);
1111 }
1112
1113 static struct syscore_ops tegra_debug_uart_syscore_ops = {
1114         .suspend = tegra_debug_uart_suspend,
1115         .resume = tegra_debug_uart_resume,
1116 };
1117
1118 struct clk *debug_uart_clk = NULL;
1119 EXPORT_SYMBOL(debug_uart_clk);
1120
1121 void tegra_console_uart_suspend(void)
1122 {
1123         if (console_suspend_enabled && debug_uart_clk)
1124                 clk_disable(debug_uart_clk);
1125 }
1126
1127 void tegra_console_uart_resume(void)
1128 {
1129         if (console_suspend_enabled && debug_uart_clk)
1130                 clk_enable(debug_uart_clk);
1131 }
1132
1133 static int tegra_debug_uart_syscore_init(void)
1134 {
1135         register_syscore_ops(&tegra_debug_uart_syscore_ops);
1136         return 0;
1137 }
1138 arch_initcall(tegra_debug_uart_syscore_init);
1139
1140 #ifdef CONFIG_DEBUG_FS
1141 static int tegra_suspend_debug_show(struct seq_file *s, void *data)
1142 {
1143         seq_printf(s, "%s\n", tegra_suspend_name[*(int *)s->private]);
1144         return 0;
1145 }
1146
1147 static int tegra_suspend_debug_open(struct inode *inode, struct file *file)
1148 {
1149         return single_open(file, tegra_suspend_debug_show, inode->i_private);
1150 }
1151
1152 static int tegra_suspend_debug_write(struct file *file,
1153         const char __user *user_buf, size_t count, loff_t *ppos)
1154 {
1155         char buf[32];
1156         int buf_size;
1157         int i;
1158         struct seq_file *s = file->private_data;
1159         enum tegra_suspend_mode *val = s->private;
1160
1161         memset(buf, 0x00, sizeof(buf));
1162         buf_size = min(count, (sizeof(buf)-1));
1163         if (copy_from_user(buf, user_buf, buf_size))
1164                 return -EFAULT;
1165
1166         for (i = 0; i < TEGRA_MAX_SUSPEND_MODE; i++) {
1167                 if (!strnicmp(buf, tegra_suspend_name[i],
1168                     strlen(tegra_suspend_name[i]))) {
1169                         if (i > pdata->suspend_mode)
1170                                 return -EINVAL;
1171                         *val = i;
1172                         return count;
1173                 }
1174         }
1175
1176         return -EINVAL;
1177 }
1178
1179 static const struct file_operations tegra_suspend_debug_fops = {
1180         .open           = tegra_suspend_debug_open,
1181         .write          = tegra_suspend_debug_write,
1182         .read           = seq_read,
1183         .llseek         = seq_lseek,
1184         .release        = single_release,
1185 };
1186
1187 static int __init tegra_suspend_debug_init(void)
1188 {
1189         struct dentry *d;
1190
1191         d = debugfs_create_file("suspend_mode", 0755, NULL,
1192                 (void *)&current_suspend_mode, &tegra_suspend_debug_fops);
1193         if (!d) {
1194                 pr_info("Failed to create suspend_mode debug file\n");
1195                 return -ENOMEM;
1196         }
1197
1198         return 0;
1199 }
1200
1201 late_initcall(tegra_suspend_debug_init);
1202 #endif