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