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