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