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