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