ARM: tegra: pm: hold cpus unti all have booted when exiting lp2
[linux-2.6.git] / arch / arm / mach-tegra / pm.c
1 /*
2  * arch/arm/mach-tegra/suspend.c
3  *
4  * CPU complex suspend & resume functions for Tegra SoCs
5  *
6  * Copyright (c) 2009-2010, 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/init.h>
25 #include <linux/io.h>
26 #include <linux/sched.h>
27 #include <linux/smp.h>
28 #include <linux/irq.h>
29 #include <linux/interrupt.h>
30 #include <linux/clk.h>
31 #include <linux/err.h>
32 #include <linux/debugfs.h>
33 #include <linux/delay.h>
34 #include <linux/suspend.h>
35 #include <linux/slab.h>
36 #include <linux/serial_reg.h>
37 #include <linux/seq_file.h>
38 #include <linux/uaccess.h>
39 #include <linux/syscore_ops.h>
40 #include <linux/cpu_pm.h>
41
42 #include <asm/cacheflush.h>
43 #include <asm/hardware/cache-l2x0.h>
44 #include <asm/hardware/gic.h>
45 #include <asm/localtimer.h>
46 #include <asm/pgalloc.h>
47 #include <asm/tlbflush.h>
48
49 #include <mach/clk.h>
50 #include <mach/iomap.h>
51 #include <mach/irqs.h>
52
53 #include "board.h"
54 #include "pm.h"
55 #include "pm-irq.h"
56 #include "sleep.h"
57
58 struct suspend_context {
59         /*
60          * The next 7 values are referenced by offset in __restart_plls
61          * in headsmp-t2.S, and should not be moved
62          */
63         u32 pllx_misc;
64         u32 pllx_base;
65         u32 pllp_misc;
66         u32 pllp_base;
67         u32 pllp_outa;
68         u32 pllp_outb;
69         u32 pll_timeout;
70
71         u32 cpu_burst;
72         u32 clk_csite_src;
73         u32 cclk_divider;
74
75         u32 mc[3];
76         u8 uart[5];
77 };
78
79 static u8 *iram_save;
80 static unsigned long iram_save_size;
81
82 struct suspend_context tegra_sctx;
83
84 static void __iomem *iram_code = IO_ADDRESS(TEGRA_IRAM_CODE_AREA);
85 static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);
86 #ifdef CONFIG_PM
87 static void __iomem *clk_rst = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
88 static void __iomem *flow_ctrl = IO_ADDRESS(TEGRA_FLOW_CTRL_BASE);
89 static void __iomem *evp_reset =
90         IO_ADDRESS(TEGRA_EXCEPTION_VECTORS_BASE) + 0x100;
91 #endif
92
93 #define TEGRA_POWER_PWRREQ_POLARITY     (1 << 8)   /* core power request polarity */
94 #define TEGRA_POWER_PWRREQ_OE           (1 << 9)   /* core power request enable */
95 #define TEGRA_POWER_SYSCLK_POLARITY     (1 << 10)  /* sys clk polarity */
96 #define TEGRA_POWER_SYSCLK_OE           (1 << 11)  /* system clock enable */
97 #define TEGRA_POWER_PWRGATE_DIS         (1 << 12)  /* power gate disabled */
98 #define TEGRA_POWER_EFFECT_LP0          (1 << 14)  /* enter LP0 when CPU pwr gated */
99 #define TEGRA_POWER_CPU_PWRREQ_POLARITY (1 << 15)  /* CPU power request polarity */
100 #define TEGRA_POWER_CPU_PWRREQ_OE       (1 << 16)  /* CPU power request enable */
101
102 #define PMC_CTRL                0x0
103 #define PMC_CTRL_LATCH_WAKEUPS  (1 << 5)
104 #define PMC_WAKE_MASK           0xc
105 #define PMC_WAKE_LEVEL          0x10
106 #define PMC_DPAD_ORIDE          0x1C
107 #define PMC_WAKE_DELAY          0xe0
108 #define PMC_DPD_SAMPLE          0x20
109
110 #define PMC_WAKE_STATUS         0x14
111 #define PMC_SW_WAKE_STATUS      0x18
112 #define PMC_COREPWRGOOD_TIMER   0x3c
113 #define PMC_SCRATCH0            0x50
114 #define PMC_SCRATCH1            0x54
115 #define PMC_CPUPWRGOOD_TIMER    0xc8
116 #define PMC_CPUPWROFF_TIMER     0xcc
117 #define PMC_COREPWROFF_TIMER    PMC_WAKE_DELAY
118
119 #define CLK_RESET_CCLK_BURST    0x20
120 #define CLK_RESET_CCLK_DIVIDER  0x24
121 #define CLK_RESET_PLLC_BASE     0x80
122 #define CLK_RESET_PLLM_BASE     0x90
123 #define CLK_RESET_PLLX_BASE     0xe0
124 #define CLK_RESET_PLLX_MISC     0xe4
125 #define CLK_RESET_PLLP_BASE     0xa0
126 #define CLK_RESET_PLLP_OUTA     0xa4
127 #define CLK_RESET_PLLP_OUTB     0xa8
128 #define CLK_RESET_PLLP_MISC     0xac
129
130 #define CLK_RESET_SOURCE_CSITE  0x1d4
131
132 #define CLK_RESET_CCLK_BURST_POLICY_SHIFT 28
133 #define CLK_RESET_CCLK_BURST_POLICY_PLLM   3
134 #define CLK_RESET_CCLK_BURST_POLICY_PLLX   8
135
136 #define FLOW_CTRL_CPU_CSR(cpu)  (0x8 + 0x10 * (cpu))
137 #define FLOW_CTRL_HALT_CPU(cpu) ((cpu) == 0 ? 0x0 : (0x4 + cpu * 0x10))
138
139 #define FLOW_CTRL_CSR_CLEAR_EVENT       (1 << 14)
140 #define FLOW_CTRL_CSR_WFE_BITMAP        (3 << 4)
141 #define FLOW_CTRL_CSR_WFE_CPU0          (1 << 4)
142 #define FLOW_CTRL_CSR_ENABLE            (1 << 0)
143
144 #define EMC_MRW_0               0x0e8
145 #define EMC_MRW_DEV_SELECTN     30
146 #define EMC_MRW_DEV_NONE        (3 << EMC_MRW_DEV_SELECTN)
147
148 #define MC_SECURITY_START       0x6c
149 #define MC_SECURITY_SIZE        0x70
150 #define MC_SECURITY_CFG2        0x7c
151
152 unsigned long tegra_pgd_phys;  /* pgd used by hotplug & LP2 bootup */
153 static pgd_t *tegra_pgd;
154
155 static int tegra_last_pclk;
156 static struct clk *tegra_pclk;
157 static const struct tegra_suspend_platform_data *pdata;
158 static enum tegra_suspend_mode current_suspend_mode = TEGRA_SUSPEND_NONE;
159
160 static DEFINE_SPINLOCK(tegra_lp2_lock);
161 static cpumask_t tegra_in_lp2;
162
163 unsigned long tegra_cpu_power_good_time(void)
164 {
165         if (WARN_ON_ONCE(!pdata))
166                 return 5000;
167
168         return pdata->cpu_timer;
169 }
170
171 unsigned long tegra_cpu_power_off_time(void)
172 {
173         if (WARN_ON_ONCE(!pdata))
174                 return 5000;
175
176         return pdata->cpu_off_timer;
177 }
178
179 /* ensures that sufficient time is passed for a register write to
180  * serialize into the 32KHz domain */
181 static void pmc_32kwritel(u32 val, unsigned long offs)
182 {
183         writel(val, pmc + offs);
184         udelay(130);
185 }
186
187 static void set_power_timers(unsigned long us_on, unsigned long us_off,
188                              long rate)
189 {
190         unsigned long long ticks;
191         unsigned long long pclk;
192
193         if (WARN_ON_ONCE(rate <= 0))
194                 pclk = 100000000;
195         else
196                 pclk = rate;
197
198         if (rate != tegra_last_pclk) {
199                 ticks = (us_on * pclk) + 999999ull;
200                 do_div(ticks, 1000000);
201                 writel((unsigned long)ticks, pmc + PMC_CPUPWRGOOD_TIMER);
202
203                 ticks = (us_off * pclk) + 999999ull;
204                 do_div(ticks, 1000000);
205                 writel((unsigned long)ticks, pmc + PMC_CPUPWROFF_TIMER);
206                 wmb();
207         }
208         tegra_last_pclk = pclk;
209 }
210
211 /*
212  * create_suspend_pgtable
213  *
214  * Creates a page table with identity mappings of physical memory and IRAM
215  * for use when the MMU is off, in addition to all the regular kernel mappings.
216  */
217 static int create_suspend_pgtable(void)
218 {
219         tegra_pgd = pgd_alloc(&init_mm);
220         if (!tegra_pgd)
221                 return -ENOMEM;
222
223         identity_mapping_add(tegra_pgd, PHYS_OFFSET, IO_IRAM_PHYS);
224         identity_mapping_add(tegra_pgd, IO_IRAM_PHYS,
225                 IO_IRAM_PHYS + SECTION_SIZE);
226
227         tegra_pgd_phys = virt_to_phys(tegra_pgd);
228
229         return 0;
230 }
231
232 static int tegra_reset_sleeping_cpu(int cpu)
233 {
234         int ret = 0;
235
236         BUG_ON(cpu == smp_processor_id());
237         tegra_pen_lock();
238
239         if (readl(pmc + PMC_SCRATCH41) == CPU_RESETTABLE)
240                 tegra_cpu_reset(cpu);
241         else
242                 ret = -EINVAL;
243
244         tegra_pen_unlock();
245
246         return ret;
247 }
248
249 static void tegra_wake_reset_cpu(int cpu)
250 {
251         u32 reg;
252
253         writel(virt_to_phys(tegra_secondary_resume), evp_reset);
254
255         /* enable cpu clock on cpu */
256         reg = readl(clk_rst + 0x4c);
257         writel(reg & ~(1 << (8 + cpu)), clk_rst + 0x4c);
258
259         reg = 0x1111 << cpu;
260         writel(reg, clk_rst + 0x344);
261
262         /* unhalt the cpu */
263         writel(0, flow_ctrl + 0x14);
264 }
265
266 #ifdef CONFIG_PM
267 /*
268  * restore_cpu_complex
269  *
270  * restores cpu clock setting, clears flow controller
271  *
272  * always called on cpu 0, even when suspend_cpu_complex was called on cpu 1
273  * in idle
274  */
275 static void restore_cpu_complex(void)
276 {
277         unsigned int reg;
278         int i;
279
280         /* restore original burst policy setting */
281
282         writel(tegra_sctx.pllx_misc, clk_rst + CLK_RESET_PLLX_MISC);
283         writel(tegra_sctx.pllx_base, clk_rst + CLK_RESET_PLLX_BASE);
284         writel(tegra_sctx.pllp_misc, clk_rst + CLK_RESET_PLLP_MISC);
285         writel(tegra_sctx.pllp_base, clk_rst + CLK_RESET_PLLP_BASE);
286         writel(tegra_sctx.pllp_outa, clk_rst + CLK_RESET_PLLP_OUTA);
287         writel(tegra_sctx.pllp_outb, clk_rst + CLK_RESET_PLLP_OUTB);
288         udelay(300);
289         writel(tegra_sctx.cclk_divider, clk_rst + CLK_RESET_CCLK_DIVIDER);
290         writel(tegra_sctx.cpu_burst, clk_rst + CLK_RESET_CCLK_BURST);
291         writel(tegra_sctx.clk_csite_src, clk_rst + CLK_RESET_SOURCE_CSITE);
292
293         /* do not power-gate the CPU when flow controlled */
294         for (i = 0; i < num_possible_cpus(); i++) {
295                 reg = readl(flow_ctrl + FLOW_CTRL_CPU_CSR(i));
296                 reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
297                 reg &= ~FLOW_CTRL_CSR_ENABLE;           /* clear enable */
298                 reg |= FLOW_CTRL_CSR_CLEAR_EVENT;       /* clear event */
299                 writel(reg, flow_ctrl + FLOW_CTRL_CPU_CSR(i));
300                 wmb();
301         }
302 }
303
304 /*
305  * suspend_cpu_complex
306  *
307  * saves pll state for use by restart_plls, prepares flow controller for
308  * transition to suspend state
309  *
310  * in suspend, always called on cpu 0
311  * in idle, called on the last cpu to request lp2
312  */
313 static void suspend_cpu_complex(void)
314 {
315         unsigned int reg;
316         int i;
317         int cpu = smp_processor_id();
318
319         /* switch coresite to clk_m, save off original source */
320         tegra_sctx.clk_csite_src = readl(clk_rst + CLK_RESET_SOURCE_CSITE);
321         writel(3<<30, clk_rst + CLK_RESET_SOURCE_CSITE);
322
323         tegra_sctx.cpu_burst = readl(clk_rst + CLK_RESET_CCLK_BURST);
324         tegra_sctx.pllx_base = readl(clk_rst + CLK_RESET_PLLX_BASE);
325         tegra_sctx.pllx_misc = readl(clk_rst + CLK_RESET_PLLX_MISC);
326         tegra_sctx.pllp_base = readl(clk_rst + CLK_RESET_PLLP_BASE);
327         tegra_sctx.pllp_outa = readl(clk_rst + CLK_RESET_PLLP_OUTA);
328         tegra_sctx.pllp_outb = readl(clk_rst + CLK_RESET_PLLP_OUTB);
329         tegra_sctx.pllp_misc = readl(clk_rst + CLK_RESET_PLLP_MISC);
330         tegra_sctx.cclk_divider = readl(clk_rst + CLK_RESET_CCLK_DIVIDER);
331
332         reg = readl(flow_ctrl + FLOW_CTRL_CPU_CSR(cpu));
333         reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
334         reg |= FLOW_CTRL_CSR_CLEAR_EVENT;       /* clear event flag */
335         reg |= FLOW_CTRL_CSR_WFE_CPU0 << cpu;   /* enable power gating on wfe */
336         reg |= FLOW_CTRL_CSR_ENABLE;            /* enable power gating */
337         writel(reg, flow_ctrl + FLOW_CTRL_CPU_CSR(cpu));
338         wmb();
339
340         for (i = 0; i < num_possible_cpus(); i++) {
341                 if (i == cpu)
342                         continue;
343                 reg = readl(flow_ctrl + FLOW_CTRL_CPU_CSR(i));
344                 reg |= FLOW_CTRL_CSR_CLEAR_EVENT;
345                 writel(reg, flow_ctrl + FLOW_CTRL_CPU_CSR(i));
346                 writel(0, flow_ctrl + FLOW_CTRL_HALT_CPU(i));
347                 wmb();
348         }
349 }
350
351 int tegra_reset_other_cpus(int cpu)
352 {
353         int i;
354         int abort = -1;
355
356         for_each_online_cpu(i) {
357                 if (i != cpu) {
358                         if (tegra_reset_sleeping_cpu(i)) {
359                                 abort = i;
360                                 break;
361                         }
362                 }
363         }
364
365         if (abort >= 0) {
366                 for_each_online_cpu(i) {
367                         if (i != cpu && i < abort)
368                                 tegra_wake_reset_cpu(i);
369                 }
370                 return -EINVAL;
371         }
372
373         return 0;
374 }
375
376 void tegra_idle_lp2_last(void)
377 {
378         u32 reg;
379         int i;
380         int cpu = smp_processor_id();
381
382         while (tegra_cpu_is_resettable_soon())
383                 cpu_relax();
384
385         if (tegra_reset_other_cpus(cpu))
386                 return;
387
388         /* Only the last cpu down does the final suspend steps */
389         reg = readl(pmc + PMC_CTRL);
390         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
391         reg |= TEGRA_POWER_PWRREQ_OE;
392         reg &= ~TEGRA_POWER_EFFECT_LP0;
393         pmc_32kwritel(reg, PMC_CTRL);
394
395         writel(virt_to_phys(tegra_resume), evp_reset);
396
397         /*
398          * we can use the locked call here, because all other cpus are in reset
399          * and irqs are disabled
400          */
401         set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer,
402                 clk_get_rate_all_locked(tegra_pclk));
403
404         cpu_cluster_pm_enter();
405
406         suspend_cpu_complex();
407         flush_cache_all();
408         outer_flush_all();
409         outer_disable();
410
411         tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
412
413         l2x0_enable();
414         restore_cpu_complex();
415         cpu_cluster_pm_exit();
416
417         for_each_online_cpu(i)
418                 if (i != cpu)
419                         tegra_wake_reset_cpu(i);
420 }
421
422 void tegra_idle_lp2(void)
423 {
424         bool last_cpu = false;
425         int cpu = smp_processor_id();
426
427         spin_lock(&tegra_lp2_lock);
428
429         cpumask_set_cpu(cpu, &tegra_in_lp2);
430         if (cpumask_equal(&tegra_in_lp2, cpu_online_mask))
431                 last_cpu = true;
432         else
433                 tegra_cpu_set_resettable_soon();
434
435         spin_unlock(&tegra_lp2_lock);
436
437         cpu_pm_enter();
438
439         if (last_cpu)
440                 tegra_idle_lp2_last();
441         else
442                 tegra_sleep_wfi(PHYS_OFFSET - PAGE_OFFSET);
443
444         cpu_pm_exit();
445
446         spin_lock(&tegra_lp2_lock);
447         cpumask_clear_cpu(cpu, &tegra_in_lp2);
448
449         /*
450          * cpus coming out of idle muck with page tables that belong to the
451          * last process executed before idle.  Don't release any cpus back to
452          * the scheduler until all cpus have booted to avoid modifying the
453          * page table of a running process on another cpu.
454          */
455         while (!cpumask_empty(&tegra_in_lp2)) {
456                 spin_unlock(&tegra_lp2_lock);
457                 cpu_relax();
458                 spin_lock(&tegra_lp2_lock);
459         }
460
461         spin_unlock(&tegra_lp2_lock);
462 }
463
464 static int tegra_common_suspend(void)
465 {
466         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
467
468         tegra_sctx.mc[0] = readl(mc + MC_SECURITY_START);
469         tegra_sctx.mc[1] = readl(mc + MC_SECURITY_SIZE);
470         tegra_sctx.mc[2] = readl(mc + MC_SECURITY_CFG2);
471
472         /* copy the reset vector and SDRAM shutdown code into IRAM */
473         memcpy(iram_save, iram_code, iram_save_size);
474         memcpy(iram_code, &tegra_iram_start, iram_save_size);
475
476         return 0;
477 }
478
479 static void tegra_common_resume(void)
480 {
481         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
482         void __iomem *emc = IO_ADDRESS(TEGRA_EMC_BASE);
483
484         /* Clear DPD sample */
485         writel(0x0, pmc + PMC_DPD_SAMPLE);
486
487         writel(tegra_sctx.mc[0], mc + MC_SECURITY_START);
488         writel(tegra_sctx.mc[1], mc + MC_SECURITY_SIZE);
489         writel(tegra_sctx.mc[2], mc + MC_SECURITY_CFG2);
490
491         /* trigger emc mode write */
492         writel(EMC_MRW_DEV_NONE, emc + EMC_MRW_0);
493
494         /* clear scratch registers shared by suspend and the reset pen */
495         writel(0x0, pmc + PMC_SCRATCH39);
496         writel(0x0, pmc + PMC_SCRATCH41);
497
498         /* restore IRAM */
499         memcpy(iram_code, iram_save, iram_save_size);
500 }
501
502 static int tegra_suspend_prepare_late(void)
503 {
504         disable_irq(INT_SYS_STATS_MON);
505         return 0;
506 }
507
508 static void tegra_suspend_wake(void)
509 {
510         enable_irq(INT_SYS_STATS_MON);
511 }
512
513 static void tegra_pm_set(enum tegra_suspend_mode mode)
514 {
515         u32 reg;
516         unsigned long rate = 32768;
517
518         reg = readl(pmc + PMC_CTRL);
519         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
520         reg |= TEGRA_POWER_PWRREQ_OE;
521         reg &= ~TEGRA_POWER_EFFECT_LP0;
522
523         switch (mode) {
524         case TEGRA_SUSPEND_LP0:
525                 /*
526                  * lp0 boots through the AVP, which then resumes the AVP to
527                  * the address in scratch 39, and the cpu to the address in
528                  * scratch 41 to tegra_resume
529                  */
530                 writel(0x0, pmc + PMC_SCRATCH39);
531                 writel(virt_to_phys(tegra_resume), pmc + PMC_SCRATCH41);
532                 reg |= TEGRA_POWER_EFFECT_LP0;
533
534                 /* Enable DPD sample to trigger sampling pads data and direction
535                  * in which pad will be driven during lp0 mode*/
536                 writel(0x1, pmc + PMC_DPD_SAMPLE);
537                 break;
538         case TEGRA_SUSPEND_LP1:
539                 /*
540                  * lp1 boots through the normal cpu reset vector pointing to
541                  * tegra_lp1_reset in IRAM, which resumes the CPU to
542                  * the address in scratch 41 to tegra_resume
543                  */
544                 writel(&tegra_lp1_reset - &tegra_iram_start +
545                         TEGRA_IRAM_CODE_AREA, evp_reset);
546                 writel(virt_to_phys(tegra_resume), pmc + PMC_SCRATCH41);
547                 break;
548         case TEGRA_SUSPEND_LP2:
549                 /*
550                  * lp2 boots through the normal cpu reset vector directly to
551                  * tegra_resume
552                  */
553                 writel(virt_to_phys(tegra_resume), evp_reset);
554                 rate = clk_get_rate(tegra_pclk);
555                 break;
556         default:
557                 BUG();
558         }
559
560         set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer, rate);
561
562         pmc_32kwritel(reg, PMC_CTRL);
563
564         /* Set warmboot flag */
565         reg = readl(pmc + PMC_SCRATCH0);
566         pmc_32kwritel(reg | 1, PMC_SCRATCH0);
567
568         pmc_32kwritel(tegra_lp0_vec_start, PMC_SCRATCH1);
569 }
570
571 static const char *lp_state[TEGRA_MAX_SUSPEND_MODE] = {
572         [TEGRA_SUSPEND_NONE] = "none",
573         [TEGRA_SUSPEND_LP2] = "LP2",
574         [TEGRA_SUSPEND_LP1] = "LP1",
575         [TEGRA_SUSPEND_LP0] = "LP0",
576 };
577
578 static int tegra_suspend_enter(suspend_state_t state)
579 {
580         enum tegra_suspend_mode mode = current_suspend_mode;
581
582         BUG_ON(mode < 0 || mode >= TEGRA_MAX_SUSPEND_MODE);
583
584         if ((mode == TEGRA_SUSPEND_LP0) && !tegra_pm_irq_lp0_allowed()) {
585                 pr_info("LP0 not used due to unsupported wakeup events\n");
586                 mode = TEGRA_SUSPEND_LP1;
587         }
588
589         tegra_common_suspend();
590
591         pr_info("Entering suspend state %s\n", lp_state[mode]);
592
593         tegra_pm_set(mode);
594
595         local_fiq_disable();
596
597         cpu_pm_enter();
598         cpu_cluster_pm_enter();
599
600         suspend_cpu_complex();
601         flush_cache_all();
602         outer_flush_all();
603         outer_disable();
604
605         if (mode == TEGRA_SUSPEND_LP2)
606                 tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
607         else
608                 tegra_sleep_core(PHYS_OFFSET - PAGE_OFFSET);
609
610         tegra_init_cache();
611         restore_cpu_complex();
612
613         cpu_cluster_pm_exit();
614         cpu_pm_exit();
615
616         local_fiq_enable();
617
618         tegra_common_resume();
619
620         return 0;
621 }
622
623 static const struct platform_suspend_ops tegra_suspend_ops = {
624         .valid          = suspend_valid_only_mem,
625         .prepare_late   = tegra_suspend_prepare_late,
626         .wake           = tegra_suspend_wake,
627         .enter          = tegra_suspend_enter,
628 };
629 #endif
630
631 void __init tegra_init_suspend(struct tegra_suspend_platform_data *plat)
632 {
633         u32 reg;
634         u32 mode;
635
636         tegra_pclk = clk_get_sys(NULL, "pclk");
637         BUG_ON(IS_ERR(tegra_pclk));
638         pdata = plat;
639         (void)reg;
640         (void)mode;
641
642         create_suspend_pgtable();
643
644 #ifdef CONFIG_PM
645         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && !tegra_lp0_vec_size) {
646                 pr_warning("Suspend mode LP0 requested, no lp0_vec\n");
647                 pr_warning("Disabling LP0\n");
648                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
649         }
650
651         iram_save_size = &tegra_iram_end - &tegra_iram_start;
652
653         iram_save = kmalloc(iram_save_size, GFP_KERNEL);
654         if (!iram_save) {
655                 pr_err("%s: unable to allocate memory for SDRAM self-refresh "
656                        "LP0/LP1 unavailable\n", __func__);
657                 plat->suspend_mode = TEGRA_SUSPEND_LP2;
658         }
659
660         /* Initialize scratch registers used for CPU LP2 synchronization */
661         writel(0, pmc + PMC_SCRATCH37);
662         writel(0, pmc + PMC_SCRATCH38);
663         writel(0, pmc + PMC_SCRATCH39);
664         writel(0, pmc + PMC_SCRATCH41);
665
666         /* Always enable CPU power request; just normal polarity is supported */
667         reg = readl(pmc + PMC_CTRL);
668         BUG_ON(reg & TEGRA_POWER_CPU_PWRREQ_POLARITY);
669         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
670         pmc_32kwritel(reg, PMC_CTRL);
671
672         /* Configure core power request and system clock control if LP0
673            is supported */
674         writel(pdata->core_timer, pmc + PMC_COREPWRGOOD_TIMER);
675         writel(pdata->core_off_timer, pmc + PMC_COREPWROFF_TIMER);
676
677         reg = readl(pmc + PMC_CTRL);
678
679         if (!pdata->sysclkreq_high)
680                 reg |= TEGRA_POWER_SYSCLK_POLARITY;
681         else
682                 reg &= ~TEGRA_POWER_SYSCLK_POLARITY;
683
684         if (!pdata->corereq_high)
685                 reg |= TEGRA_POWER_PWRREQ_POLARITY;
686         else
687                 reg &= ~TEGRA_POWER_PWRREQ_POLARITY;
688
689         /* configure output inverters while the request is tristated */
690         pmc_32kwritel(reg, PMC_CTRL);
691
692         /* now enable requests */
693         reg |= TEGRA_POWER_SYSCLK_OE;
694         reg |= TEGRA_POWER_PWRREQ_OE;
695         pmc_32kwritel(reg, PMC_CTRL);
696
697         if (pdata->suspend_mode == TEGRA_SUSPEND_LP0)
698                 tegra2_lp0_suspend_init();
699
700         suspend_set_ops(&tegra_suspend_ops);
701 #endif
702
703         current_suspend_mode = plat->suspend_mode;
704 }
705
706 static int tegra_debug_uart_suspend(void)
707 {
708         void __iomem *uart;
709         u32 lcr;
710
711         if (TEGRA_DEBUG_UART_BASE == 0)
712                 return 0;
713
714         uart = IO_ADDRESS(TEGRA_DEBUG_UART_BASE);
715
716         lcr = readb(uart + UART_LCR * 4);
717
718         tegra_sctx.uart[0] = lcr;
719         tegra_sctx.uart[1] = readb(uart + UART_MCR * 4);
720
721         /* DLAB = 0 */
722         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
723
724         tegra_sctx.uart[2] = readb(uart + UART_IER * 4);
725
726         /* DLAB = 1 */
727         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
728
729         tegra_sctx.uart[3] = readb(uart + UART_DLL * 4);
730         tegra_sctx.uart[4] = readb(uart + UART_DLM * 4);
731
732         writeb(lcr, uart + UART_LCR * 4);
733
734         return 0;
735 }
736
737 static void tegra_debug_uart_resume(void)
738 {
739         void __iomem *uart;
740         u32 lcr;
741
742         if (TEGRA_DEBUG_UART_BASE == 0)
743                 return;
744
745         uart = IO_ADDRESS(TEGRA_DEBUG_UART_BASE);
746
747         lcr = tegra_sctx.uart[0];
748
749         writeb(tegra_sctx.uart[1], uart + UART_MCR * 4);
750
751         /* DLAB = 0 */
752         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
753
754         writeb(tegra_sctx.uart[2], uart + UART_IER * 4);
755
756         /* DLAB = 1 */
757         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
758
759         writeb(tegra_sctx.uart[3], uart + UART_DLL * 4);
760         writeb(tegra_sctx.uart[4], uart + UART_DLM * 4);
761
762         writeb(lcr, uart + UART_LCR * 4);
763 }
764
765 static struct syscore_ops tegra_debug_uart_syscore_ops = {
766         .suspend = tegra_debug_uart_suspend,
767         .resume = tegra_debug_uart_resume,
768 };
769
770 static int tegra_debug_uart_syscore_init(void)
771 {
772         register_syscore_ops(&tegra_debug_uart_syscore_ops);
773         return 0;
774 }
775 arch_initcall(tegra_debug_uart_syscore_init);
776
777 #ifdef CONFIG_DEBUG_FS
778 static const char *tegra_suspend_name[TEGRA_MAX_SUSPEND_MODE] = {
779         [TEGRA_SUSPEND_NONE]    = "none",
780         [TEGRA_SUSPEND_LP2]     = "lp2",
781         [TEGRA_SUSPEND_LP1]     = "lp1",
782         [TEGRA_SUSPEND_LP0]     = "lp0",
783 };
784
785 static int tegra_suspend_debug_show(struct seq_file *s, void *data)
786 {
787         seq_printf(s, "%s\n", tegra_suspend_name[*(int *)s->private]);
788         return 0;
789 }
790
791 static int tegra_suspend_debug_open(struct inode *inode, struct file *file)
792 {
793         return single_open(file, tegra_suspend_debug_show, inode->i_private);
794 }
795
796 static int tegra_suspend_debug_write(struct file *file,
797         const char __user *user_buf, size_t count, loff_t *ppos)
798 {
799         char buf[32];
800         int buf_size;
801         int i;
802         struct seq_file *s = file->private_data;
803         enum tegra_suspend_mode *val = s->private;
804
805         memset(buf, 0x00, sizeof(buf));
806         buf_size = min(count, (sizeof(buf)-1));
807         if (copy_from_user(buf, user_buf, buf_size))
808                 return -EFAULT;
809
810         for (i = 0; i < TEGRA_MAX_SUSPEND_MODE; i++) {
811                 if (!strnicmp(buf, tegra_suspend_name[i],
812                     strlen(tegra_suspend_name[i]))) {
813                         if (i > pdata->suspend_mode)
814                                 return -EINVAL;
815                         *val = i;
816                         return count;
817                 }
818         }
819
820         return -EINVAL;
821 }
822
823 static const struct file_operations tegra_suspend_debug_fops = {
824         .open           = tegra_suspend_debug_open,
825         .write          = tegra_suspend_debug_write,
826         .read           = seq_read,
827         .llseek         = seq_lseek,
828         .release        = single_release,
829 };
830
831 static int __init tegra_suspend_debug_init(void)
832 {
833         struct dentry *d;
834
835         d = debugfs_create_file("suspend_mode", 0755, NULL,
836                 (void *)&current_suspend_mode, &tegra_suspend_debug_fops);
837         if (!d) {
838                 pr_info("Failed to create suspend_mode debug file\n");
839                 return -ENOMEM;
840         }
841
842         return 0;
843 }
844
845 late_initcall(tegra_suspend_debug_init);
846 #endif