arm: tegra: Set G-CPU L2 cache latency to 0x442/552.
[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. For calls resulting from CPU LP2 in
417            idle or system suspend, the local timer was shut down and
418            timekeeping switched over to the global system timer. In this
419            case keep local timer disabled, and restore only periodic load. */
420         if (!(mode & (TEGRA_POWER_CLUSTER_MASK |
421                       TEGRA_POWER_CLUSTER_IMMEDIATE)))
422                 tegra_sctx.twd.twd_ctrl = 0;
423         tegra_twd_resume(&tegra_sctx.twd);
424 }
425
426 /*
427  * suspend_cpu_complex
428  *
429  * saves pll state for use by restart_plls, prepares flow controller for
430  * transition to suspend state
431  *
432  * Must always be called on cpu 0.
433  */
434 static void suspend_cpu_complex(u32 mode)
435 {
436         int cpu = smp_processor_id();
437         unsigned int reg;
438         int i;
439
440         BUG_ON(cpu != 0);
441
442         /* switch coresite to clk_m, save off original source */
443         tegra_sctx.clk_csite_src = readl(clk_rst + CLK_RESET_SOURCE_CSITE);
444         writel(3<<30, clk_rst + CLK_RESET_SOURCE_CSITE);
445
446         tegra_sctx.cpu_burst = readl(clk_rst + CLK_RESET_CCLK_BURST);
447         tegra_sctx.pllx_base = readl(clk_rst + CLK_RESET_PLLX_BASE);
448         tegra_sctx.pllx_misc = readl(clk_rst + CLK_RESET_PLLX_MISC);
449         tegra_sctx.pllp_base = readl(clk_rst + CLK_RESET_PLLP_BASE);
450         tegra_sctx.pllp_outa = readl(clk_rst + CLK_RESET_PLLP_OUTA);
451         tegra_sctx.pllp_outb = readl(clk_rst + CLK_RESET_PLLP_OUTB);
452         tegra_sctx.pllp_misc = readl(clk_rst + CLK_RESET_PLLP_MISC);
453         tegra_sctx.cclk_divider = readl(clk_rst + CLK_RESET_CCLK_DIVIDER);
454
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         if (pdata->combined_req)
539                 mode &= ~TEGRA_POWER_PWRREQ_OE;
540         else
541                 mode |= TEGRA_POWER_PWRREQ_OE;
542         mode &= ~TEGRA_POWER_EFFECT_LP0;
543         pmc_32kwritel(mode, PMC_CTRL);
544         mode |= flags;
545
546         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_start);
547
548         /*
549          * We can use clk_get_rate_all_locked() here, because all other cpus
550          * are in LP2 state and irqs are disabled
551          */
552         if (flags & TEGRA_POWER_CLUSTER_MASK) {
553                 set_power_timers(pdata->cpu_timer, 0,
554                         clk_get_rate_all_locked(tegra_pclk));
555                 tegra_cluster_switch_prolog(mode);
556         } else {
557                 set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer,
558                         clk_get_rate_all_locked(tegra_pclk));
559         }
560
561         if (sleep_time)
562                 tegra_lp2_set_trigger(sleep_time);
563
564         cpu_cluster_pm_enter();
565         suspend_cpu_complex(mode);
566         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_prolog);
567         flush_cache_all();
568         outer_disable();
569
570         tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
571
572 #ifdef CONFIG_CACHE_L2X0
573         tegra_init_cache(false);
574         l2x0_enable();
575 #endif
576         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_switch);
577         restore_cpu_complex(mode);
578         cpu_cluster_pm_exit();
579
580         remain = tegra_lp2_timer_remain();
581         if (sleep_time)
582                 tegra_lp2_set_trigger(0);
583
584         if (flags & TEGRA_POWER_CLUSTER_MASK)
585                 tegra_cluster_switch_epilog(mode);
586
587         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_epilog);
588
589 #if INSTRUMENT_CLUSTER_SWITCH
590         if (flags & TEGRA_POWER_CLUSTER_MASK) {
591                 pr_err("%s: prolog %lu us, switch %lu us, epilog %lu us, total %lu us\n",
592                         is_lp_cluster() ? "G=>LP" : "LP=>G",
593                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_prolog] -
594                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_start],
595                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_switch] -
596                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_prolog],
597                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_epilog] -
598                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_switch],
599                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_epilog] -
600                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_start]);
601         }
602 #endif
603         return remain;
604 }
605
606 static int tegra_common_suspend(void)
607 {
608         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
609
610         tegra_sctx.mc[0] = readl(mc + MC_SECURITY_START);
611         tegra_sctx.mc[1] = readl(mc + MC_SECURITY_SIZE);
612         tegra_sctx.mc[2] = readl(mc + MC_SECURITY_CFG2);
613
614         /* copy the reset vector and SDRAM shutdown code into IRAM */
615         memcpy(iram_save, iram_code, iram_save_size);
616         memcpy(iram_code, tegra_iram_start(), iram_save_size);
617
618         return 0;
619 }
620
621 static void tegra_common_resume(void)
622 {
623         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
624 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
625         void __iomem *emc = IO_ADDRESS(TEGRA_EMC_BASE);
626 #endif
627
628         /* Clear DPD sample */
629         writel(0x0, pmc + PMC_DPD_SAMPLE);
630
631         writel(tegra_sctx.mc[0], mc + MC_SECURITY_START);
632         writel(tegra_sctx.mc[1], mc + MC_SECURITY_SIZE);
633         writel(tegra_sctx.mc[2], mc + MC_SECURITY_CFG2);
634 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
635         /* trigger emc mode write */
636         writel(EMC_MRW_DEV_NONE, emc + EMC_MRW_0);
637 #endif
638         /* clear scratch registers shared by suspend and the reset pen */
639         writel(0x0, pmc + PMC_SCRATCH39);
640         writel(0x0, pmc + PMC_SCRATCH41);
641
642         /* restore IRAM */
643         memcpy(iram_code, iram_save, iram_save_size);
644 }
645
646 static int tegra_suspend_prepare_late(void)
647 {
648 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
649         disable_irq(INT_SYS_STATS_MON);
650 #endif
651         return 0;
652 }
653
654 static void tegra_suspend_wake(void)
655 {
656 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
657         enable_irq(INT_SYS_STATS_MON);
658 #endif
659 }
660
661 static void tegra_pm_set(enum tegra_suspend_mode mode)
662 {
663         u32 reg, boot_flag;
664         unsigned long rate = 32768;
665
666         reg = readl(pmc + PMC_CTRL);
667         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
668         if (pdata->combined_req)
669                 reg &= ~TEGRA_POWER_PWRREQ_OE;
670         else
671                 reg |= TEGRA_POWER_PWRREQ_OE;
672         reg &= ~TEGRA_POWER_EFFECT_LP0;
673
674         switch (mode) {
675         case TEGRA_SUSPEND_LP0:
676                 if (pdata->combined_req) {
677                         reg |= TEGRA_POWER_PWRREQ_OE;
678                         reg &= ~TEGRA_POWER_CPU_PWRREQ_OE;
679                 }
680
681                 /*
682                  * LP0 boots through the AVP, which then resumes the AVP to
683                  * the address in scratch 39, and the cpu to the address in
684                  * scratch 41 to tegra_resume
685                  */
686                 writel(0x0, pmc + PMC_SCRATCH39);
687
688                 /* Enable DPD sample to trigger sampling pads data and direction
689                  * in which pad will be driven during lp0 mode*/
690                 writel(0x1, pmc + PMC_DPD_SAMPLE);
691
692                 /* Set warmboot flag */
693                 boot_flag = readl(pmc + PMC_SCRATCH0);
694                 pmc_32kwritel(boot_flag | 1, PMC_SCRATCH0);
695
696                 pmc_32kwritel(tegra_lp0_vec_start, PMC_SCRATCH1);
697
698                 reg |= TEGRA_POWER_EFFECT_LP0;
699                 /* No break here. LP0 code falls through to write SCRATCH41 */
700         case TEGRA_SUSPEND_LP1:
701                 __raw_writel(virt_to_phys(tegra_resume), pmc + PMC_SCRATCH41);
702                 wmb();
703                 break;
704         case TEGRA_SUSPEND_LP2:
705                 rate = clk_get_rate(tegra_pclk);
706                 break;
707         case TEGRA_SUSPEND_NONE:
708                 return;
709         default:
710                 BUG();
711         }
712
713         set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer, rate);
714
715         pmc_32kwritel(reg, PMC_CTRL);
716 }
717
718 static const char *lp_state[TEGRA_MAX_SUSPEND_MODE] = {
719         [TEGRA_SUSPEND_NONE] = "none",
720         [TEGRA_SUSPEND_LP2] = "LP2",
721         [TEGRA_SUSPEND_LP1] = "LP1",
722         [TEGRA_SUSPEND_LP0] = "LP0",
723 };
724
725 static int tegra_suspend_enter(suspend_state_t state)
726 {
727         int ret;
728
729         if (pdata && pdata->board_suspend)
730                 pdata->board_suspend(current_suspend_mode, TEGRA_SUSPEND_BEFORE_PERIPHERAL);
731
732         ret = tegra_suspend_dram(current_suspend_mode, 0);
733
734         if (pdata && pdata->board_resume)
735                 pdata->board_resume(current_suspend_mode, TEGRA_RESUME_AFTER_PERIPHERAL);
736
737         return ret;
738 }
739
740 static void tegra_suspend_check_pwr_stats(void)
741 {
742         /* cpus and l2 are powered off later */
743         unsigned long pwrgate_partid_mask =
744 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC)
745                 (1 << TEGRA_POWERGATE_HEG)      |
746                 (1 << TEGRA_POWERGATE_SATA)     |
747                 (1 << TEGRA_POWERGATE_3D1)      |
748 #endif
749                 (1 << TEGRA_POWERGATE_3D)       |
750                 (1 << TEGRA_POWERGATE_VENC)     |
751                 (1 << TEGRA_POWERGATE_PCIE)     |
752                 (1 << TEGRA_POWERGATE_VDEC)     |
753                 (1 << TEGRA_POWERGATE_MPE);
754
755         int partid;
756
757         for_each_set_bit(partid, &pwrgate_partid_mask, BITS_PER_LONG)
758                 if (tegra_powergate_is_powered(partid) == 1)
759                         pr_warning("partition %s is left on before suspend\n",
760                                 tegra_powergate_get_name(partid));
761
762         return;
763 }
764
765 int tegra_suspend_dram(enum tegra_suspend_mode mode, unsigned int flags)
766 {
767         BUG_ON(mode < 0 || mode >= TEGRA_MAX_SUSPEND_MODE);
768
769         if ((mode == TEGRA_SUSPEND_LP0) && !tegra_pm_irq_lp0_allowed()) {
770                 pr_info("LP0 not used due to unsupported wakeup events\n");
771                 mode = TEGRA_SUSPEND_LP1;
772         }
773
774         if ((mode == TEGRA_SUSPEND_LP0) || (mode == TEGRA_SUSPEND_LP1))
775                 tegra_suspend_check_pwr_stats();
776
777         tegra_common_suspend();
778
779         tegra_pm_set(mode);
780
781         if (pdata && pdata->board_suspend)
782                 pdata->board_suspend(mode, TEGRA_SUSPEND_BEFORE_CPU);
783
784         local_fiq_disable();
785
786         cpu_pm_enter();
787         cpu_cluster_pm_enter();
788
789         if (mode == TEGRA_SUSPEND_LP0) {
790 #ifdef CONFIG_TEGRA_CLUSTER_CONTROL
791                 u32 reg = readl(pmc + PMC_SCRATCH4);
792                 if (is_lp_cluster())
793                         reg |= PMC_SCRATCH4_WAKE_CLUSTER_MASK;
794                 else
795                         reg &= (~PMC_SCRATCH4_WAKE_CLUSTER_MASK);
796                 pmc_32kwritel(reg, PMC_SCRATCH4);
797 #endif
798                 tegra_lp0_suspend_mc();
799                 tegra_cpu_reset_handler_save();
800
801         }
802         else if (mode == TEGRA_SUSPEND_LP1)
803                 *iram_cpu_lp1_mask = 1;
804
805         suspend_cpu_complex(flags);
806
807         flush_cache_all();
808         outer_flush_all();
809         outer_disable();
810
811         if (mode == TEGRA_SUSPEND_LP2)
812                 tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
813         else
814                 tegra_sleep_core(PHYS_OFFSET - PAGE_OFFSET);
815
816         tegra_init_cache(true);
817
818         if (mode == TEGRA_SUSPEND_LP0) {
819                 tegra_cpu_reset_handler_restore();
820                 tegra_lp0_resume_mc();
821         } else if (mode == TEGRA_SUSPEND_LP1)
822                 *iram_cpu_lp1_mask = 0;
823
824         restore_cpu_complex(flags);
825
826         /* for platforms where the core & CPU power requests are
827          * combined as a single request to the PMU, transition out
828          * of LP0 state by temporarily enabling both requests
829          */
830         if (mode == TEGRA_SUSPEND_LP0 && pdata->combined_req) {
831                 u32 reg;
832                 reg = readl(pmc + PMC_CTRL);
833                 reg |= TEGRA_POWER_CPU_PWRREQ_OE;
834                 pmc_32kwritel(reg, PMC_CTRL);
835                 reg &= ~TEGRA_POWER_PWRREQ_OE;
836                 pmc_32kwritel(reg, PMC_CTRL);
837         }
838
839         cpu_cluster_pm_exit();
840         cpu_pm_exit();
841
842         if (pdata && pdata->board_resume)
843                 pdata->board_resume(mode, TEGRA_RESUME_AFTER_CPU);
844
845         local_fiq_enable();
846
847         tegra_common_resume();
848
849         return 0;
850 }
851
852 /*
853  * Function pointers to optional board specific function
854  */
855 void (*tegra_deep_sleep)(int);
856 EXPORT_SYMBOL(tegra_deep_sleep);
857
858 static int tegra_suspend_prepare(void)
859 {
860         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
861                 tegra_deep_sleep(1);
862         return 0;
863 }
864
865 static void tegra_suspend_finish(void)
866 {
867         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
868                 tegra_deep_sleep(0);
869 }
870
871 static const struct platform_suspend_ops tegra_suspend_ops = {
872         .valid          = suspend_valid_only_mem,
873         .prepare        = tegra_suspend_prepare,
874         .finish         = tegra_suspend_finish,
875         .prepare_late   = tegra_suspend_prepare_late,
876         .wake           = tegra_suspend_wake,
877         .enter          = tegra_suspend_enter,
878 };
879
880 static ssize_t suspend_mode_show(struct kobject *kobj,
881                                         struct kobj_attribute *attr, char *buf)
882 {
883         char *start = buf;
884         char *end = buf + PAGE_SIZE;
885
886         start += scnprintf(start, end - start, "%s ", \
887                                 tegra_suspend_name[current_suspend_mode]);
888         start += scnprintf(start, end - start, "\n");
889
890         return start - buf;
891 }
892
893 static ssize_t suspend_mode_store(struct kobject *kobj,
894                                         struct kobj_attribute *attr,
895                                         const char *buf, size_t n)
896 {
897         int len;
898         const char *name_ptr;
899         enum tegra_suspend_mode new_mode;
900
901         name_ptr = buf;
902         while (*name_ptr && !isspace(*name_ptr))
903                 name_ptr++;
904         len = name_ptr - buf;
905         if (!len)
906                 goto bad_name;
907
908         for (new_mode = TEGRA_SUSPEND_NONE; \
909                         new_mode < TEGRA_MAX_SUSPEND_MODE; ++new_mode) {
910                 if (!strncmp(buf, tegra_suspend_name[new_mode], len)) {
911                         current_suspend_mode = new_mode;
912                         break;
913                 }
914         }
915
916 bad_name:
917         return n;
918 }
919
920 static struct kobj_attribute suspend_mode_attribute =
921         __ATTR(mode, 0644, suspend_mode_show, suspend_mode_store);
922
923 static struct kobject *suspend_kobj;
924 #endif
925
926 #ifdef CONFIG_PM_SLEEP
927 static int tegra_pm_enter_suspend(void)
928 {
929         pr_info("Entering suspend state %s\n", lp_state[current_suspend_mode]);
930         if (current_suspend_mode == TEGRA_SUSPEND_LP0)
931                 tegra_lp0_cpu_mode(true);
932         return 0;
933 }
934
935 static void tegra_pm_enter_resume(void)
936 {
937         if (current_suspend_mode == TEGRA_SUSPEND_LP0)
938                 tegra_lp0_cpu_mode(false);
939         pr_info("Exited suspend state %s\n", lp_state[current_suspend_mode]);
940 }
941
942 static struct syscore_ops tegra_pm_enter_syscore_ops = {
943         .suspend = tegra_pm_enter_suspend,
944         .resume = tegra_pm_enter_resume,
945 };
946
947 static __init int tegra_pm_enter_syscore_init(void)
948 {
949         register_syscore_ops(&tegra_pm_enter_syscore_ops);
950         return 0;
951 }
952 subsys_initcall(tegra_pm_enter_syscore_init);
953 #endif
954
955 void __init tegra_init_suspend(struct tegra_suspend_platform_data *plat)
956 {
957         u32 reg;
958         u32 mode;
959
960         tegra_pclk = clk_get_sys(NULL, "pclk");
961         BUG_ON(IS_ERR(tegra_pclk));
962         pdata = plat;
963         (void)reg;
964         (void)mode;
965
966 #ifndef CONFIG_PM_SLEEP
967         if (plat->suspend_mode != TEGRA_SUSPEND_NONE) {
968                 pr_warning("%s: Suspend requires CONFIG_PM_SLEEP -- "
969                            "disabling suspend\n", __func__);
970                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
971         }
972 #else
973         if (create_suspend_pgtable() < 0) {
974                 pr_err("%s: PGD memory alloc failed -- LP0/LP1/LP2 unavailable\n",
975                                 __func__);
976                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
977                 goto fail;
978         }
979
980         if (alloc_suspend_context() < 0) {
981                 pr_err("%s: CPU context alloc failed -- LP0/LP1/LP2 unavailable\n",
982                                 __func__);
983                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
984                 goto fail;
985         }
986
987         if ((tegra_chip_id == TEGRA30) &&
988             (tegra_revision == TEGRA_REVISION_A01) &&
989             (plat->suspend_mode == TEGRA_SUSPEND_LP0)) {
990                 /* Tegra 3 A01 supports only LP1 */
991                 pr_warning("%s: Suspend mode LP0 is not supported on A01 "
992                            "-- disabling LP0\n", __func__);
993                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
994         }
995         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && tegra_lp0_vec_size &&
996                 tegra_lp0_vec_relocate) {
997                 unsigned char *reloc_lp0;
998                 unsigned long tmp;
999                 void __iomem *orig;
1000                 reloc_lp0 = kmalloc(tegra_lp0_vec_size + L1_CACHE_BYTES - 1,
1001                                         GFP_KERNEL);
1002                 WARN_ON(!reloc_lp0);
1003                 if (!reloc_lp0) {
1004                         pr_err("%s: Failed to allocate reloc_lp0\n",
1005                                 __func__);
1006                         goto out;
1007                 }
1008
1009                 orig = ioremap(tegra_lp0_vec_start, tegra_lp0_vec_size);
1010                 WARN_ON(!orig);
1011                 if (!orig) {
1012                         pr_err("%s: Failed to map tegra_lp0_vec_start %08lx\n",
1013                                 __func__, tegra_lp0_vec_start);
1014                         kfree(reloc_lp0);
1015                         goto out;
1016                 }
1017
1018                 tmp = (unsigned long) reloc_lp0;
1019                 tmp = (tmp + L1_CACHE_BYTES - 1) & ~(L1_CACHE_BYTES - 1);
1020                 reloc_lp0 = (unsigned char *)tmp;
1021                 memcpy(reloc_lp0, orig, tegra_lp0_vec_size);
1022                 iounmap(orig);
1023                 tegra_lp0_vec_start = virt_to_phys(reloc_lp0);
1024         }
1025
1026 out:
1027         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && !tegra_lp0_vec_size) {
1028                 pr_warning("%s: Suspend mode LP0 requested, no lp0_vec "
1029                            "provided by bootlader -- disabling LP0\n",
1030                            __func__);
1031                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
1032         }
1033
1034         iram_save_size = tegra_iram_end() - tegra_iram_start();
1035
1036         iram_save = kmalloc(iram_save_size, GFP_KERNEL);
1037         if (!iram_save && (plat->suspend_mode >= TEGRA_SUSPEND_LP1)) {
1038                 pr_err("%s: unable to allocate memory for SDRAM self-refresh "
1039                        "-- LP0/LP1 unavailable\n", __func__);
1040                 plat->suspend_mode = TEGRA_SUSPEND_LP2;
1041         }
1042
1043         /* !!!FIXME!!! THIS IS TEGRA2 ONLY */
1044         /* Initialize scratch registers used for CPU LP2 synchronization */
1045         writel(0, pmc + PMC_SCRATCH37);
1046         writel(0, pmc + PMC_SCRATCH38);
1047         writel(0, pmc + PMC_SCRATCH39);
1048         writel(0, pmc + PMC_SCRATCH41);
1049
1050         /* Always enable CPU power request; just normal polarity is supported */
1051         reg = readl(pmc + PMC_CTRL);
1052         BUG_ON(reg & TEGRA_POWER_CPU_PWRREQ_POLARITY);
1053         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
1054         pmc_32kwritel(reg, PMC_CTRL);
1055
1056         /* Configure core power request and system clock control if LP0
1057            is supported */
1058         __raw_writel(pdata->core_timer, pmc + PMC_COREPWRGOOD_TIMER);
1059         __raw_writel(pdata->core_off_timer, pmc + PMC_COREPWROFF_TIMER);
1060
1061         reg = readl(pmc + PMC_CTRL);
1062
1063         if (!pdata->sysclkreq_high)
1064                 reg |= TEGRA_POWER_SYSCLK_POLARITY;
1065         else
1066                 reg &= ~TEGRA_POWER_SYSCLK_POLARITY;
1067
1068         if (!pdata->corereq_high)
1069                 reg |= TEGRA_POWER_PWRREQ_POLARITY;
1070         else
1071                 reg &= ~TEGRA_POWER_PWRREQ_POLARITY;
1072
1073         /* configure output inverters while the request is tristated */
1074         pmc_32kwritel(reg, PMC_CTRL);
1075
1076         /* now enable requests */
1077         reg |= TEGRA_POWER_SYSCLK_OE;
1078         if (!pdata->combined_req)
1079                 reg |= TEGRA_POWER_PWRREQ_OE;
1080         pmc_32kwritel(reg, PMC_CTRL);
1081
1082         if (pdata->suspend_mode == TEGRA_SUSPEND_LP0)
1083                 tegra_lp0_suspend_init();
1084
1085         suspend_set_ops(&tegra_suspend_ops);
1086
1087         /* Create /sys/power/suspend/type */
1088         suspend_kobj = kobject_create_and_add("suspend", power_kobj);
1089         if (suspend_kobj) {
1090                 if (sysfs_create_file(suspend_kobj, \
1091                                                 &suspend_mode_attribute.attr))
1092                         pr_err("%s: sysfs_create_file suspend type failed!\n",
1093                                                                 __func__);
1094         }
1095
1096         iram_cpu_lp2_mask = tegra_cpu_lp2_mask;
1097         iram_cpu_lp1_mask = tegra_cpu_lp1_mask;
1098 fail:
1099 #endif
1100         if (plat->suspend_mode == TEGRA_SUSPEND_NONE)
1101                 tegra_lp2_in_idle(false);
1102
1103         current_suspend_mode = plat->suspend_mode;
1104 }
1105
1106 unsigned long debug_uart_port_base = 0;
1107 EXPORT_SYMBOL(debug_uart_port_base);
1108
1109 static int tegra_debug_uart_suspend(void)
1110 {
1111         void __iomem *uart;
1112         u32 lcr;
1113
1114         if (!debug_uart_port_base)
1115                 return 0;
1116
1117         uart = IO_ADDRESS(debug_uart_port_base);
1118
1119         lcr = readb(uart + UART_LCR * 4);
1120
1121         tegra_sctx.uart[0] = lcr;
1122         tegra_sctx.uart[1] = readb(uart + UART_MCR * 4);
1123
1124         /* DLAB = 0 */
1125         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1126
1127         tegra_sctx.uart[2] = readb(uart + UART_IER * 4);
1128
1129         /* DLAB = 1 */
1130         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1131
1132         tegra_sctx.uart[3] = readb(uart + UART_DLL * 4);
1133         tegra_sctx.uart[4] = readb(uart + UART_DLM * 4);
1134
1135         writeb(lcr, uart + UART_LCR * 4);
1136
1137         return 0;
1138 }
1139
1140 static void tegra_debug_uart_resume(void)
1141 {
1142         void __iomem *uart;
1143         u32 lcr;
1144
1145         if (!debug_uart_port_base)
1146                 return;
1147
1148         uart = IO_ADDRESS(debug_uart_port_base);
1149
1150         lcr = tegra_sctx.uart[0];
1151
1152         writeb(tegra_sctx.uart[1], uart + UART_MCR * 4);
1153
1154         /* DLAB = 0 */
1155         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1156
1157         writeb(UART_FCR_ENABLE_FIFO | UART_FCR_T_TRIG_01 | UART_FCR_R_TRIG_01,
1158                         uart + UART_FCR * 4);
1159
1160         writeb(tegra_sctx.uart[2], uart + UART_IER * 4);
1161
1162         /* DLAB = 1 */
1163         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1164
1165         writeb(tegra_sctx.uart[3], uart + UART_DLL * 4);
1166         writeb(tegra_sctx.uart[4], uart + UART_DLM * 4);
1167
1168         writeb(lcr, uart + UART_LCR * 4);
1169 }
1170
1171 static struct syscore_ops tegra_debug_uart_syscore_ops = {
1172         .suspend = tegra_debug_uart_suspend,
1173         .resume = tegra_debug_uart_resume,
1174 };
1175
1176 struct clk *debug_uart_clk = NULL;
1177 EXPORT_SYMBOL(debug_uart_clk);
1178
1179 void tegra_console_uart_suspend(void)
1180 {
1181         if (console_suspend_enabled && debug_uart_clk)
1182                 clk_disable(debug_uart_clk);
1183 }
1184
1185 void tegra_console_uart_resume(void)
1186 {
1187         if (console_suspend_enabled && debug_uart_clk)
1188                 clk_enable(debug_uart_clk);
1189 }
1190
1191 static int tegra_debug_uart_syscore_init(void)
1192 {
1193         register_syscore_ops(&tegra_debug_uart_syscore_ops);
1194         return 0;
1195 }
1196 arch_initcall(tegra_debug_uart_syscore_init);
1197
1198 #ifdef CONFIG_DEBUG_FS
1199 static int tegra_suspend_debug_show(struct seq_file *s, void *data)
1200 {
1201         seq_printf(s, "%s\n", tegra_suspend_name[*(int *)s->private]);
1202         return 0;
1203 }
1204
1205 static int tegra_suspend_debug_open(struct inode *inode, struct file *file)
1206 {
1207         return single_open(file, tegra_suspend_debug_show, inode->i_private);
1208 }
1209
1210 static int tegra_suspend_debug_write(struct file *file,
1211         const char __user *user_buf, size_t count, loff_t *ppos)
1212 {
1213         char buf[32];
1214         int buf_size;
1215         int i;
1216         struct seq_file *s = file->private_data;
1217         enum tegra_suspend_mode *val = s->private;
1218
1219         memset(buf, 0x00, sizeof(buf));
1220         buf_size = min(count, (sizeof(buf)-1));
1221         if (copy_from_user(buf, user_buf, buf_size))
1222                 return -EFAULT;
1223
1224         for (i = 0; i < TEGRA_MAX_SUSPEND_MODE; i++) {
1225                 if (!strnicmp(buf, tegra_suspend_name[i],
1226                     strlen(tegra_suspend_name[i]))) {
1227                         if (i > pdata->suspend_mode)
1228                                 return -EINVAL;
1229                         *val = i;
1230                         return count;
1231                 }
1232         }
1233
1234         return -EINVAL;
1235 }
1236
1237 static const struct file_operations tegra_suspend_debug_fops = {
1238         .open           = tegra_suspend_debug_open,
1239         .write          = tegra_suspend_debug_write,
1240         .read           = seq_read,
1241         .llseek         = seq_lseek,
1242         .release        = single_release,
1243 };
1244
1245 static int __init tegra_suspend_debug_init(void)
1246 {
1247         struct dentry *d;
1248
1249         d = debugfs_create_file("suspend_mode", 0755, NULL,
1250                 (void *)&current_suspend_mode, &tegra_suspend_debug_fops);
1251         if (!d) {
1252                 pr_info("Failed to create suspend_mode debug file\n");
1253                 return -ENOMEM;
1254         }
1255
1256         return 0;
1257 }
1258
1259 late_initcall(tegra_suspend_debug_init);
1260 #endif