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