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