f42d4fe57361f12c8aea860d702227a1677de38f
[linux-3.10.git] / arch / arm / mach-tegra / pm.c
1 /*
2  * arch/arm/mach-tegra/pm.c
3  *
4  * CPU complex suspend & resume functions for Tegra SoCs
5  *
6  * Copyright (c) 2009-2011, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/ctype.h>
25 #include <linux/init.h>
26 #include <linux/io.h>
27 #include <linux/sched.h>
28 #include <linux/smp.h>
29 #include <linux/irq.h>
30 #include <linux/interrupt.h>
31 #include <linux/clk.h>
32 #include <linux/err.h>
33 #include <linux/debugfs.h>
34 #include <linux/delay.h>
35 #include <linux/suspend.h>
36 #include <linux/slab.h>
37 #include <linux/serial_reg.h>
38 #include <linux/seq_file.h>
39 #include <linux/uaccess.h>
40 #include <linux/syscore_ops.h>
41 #include <linux/cpu_pm.h>
42 #include <linux/clk/tegra.h>
43 #include <linux/export.h>
44 #include <linux/vmalloc.h>
45 #include <linux/memblock.h>
46 #include <linux/console.h>
47
48 #include <asm/cacheflush.h>
49 #include <asm/hardware/cache-l2x0.h>
50 #include <asm/idmap.h>
51 #include <asm/localtimer.h>
52 #include <asm/pgalloc.h>
53 #include <asm/pgtable.h>
54 #include <asm/tlbflush.h>
55
56 #include <mach/irqs.h>
57 #include <mach/powergate.h>
58
59 #include "board.h"
60 #include "clock.h"
61 #include "cpuidle.h"
62 #include "flowctrl.h"
63 #include "fuse.h"
64 #include "gic.h"
65 #include "iomap.h"
66 #include "pm.h"
67 #include "pm-irq.h"
68 #include "reset.h"
69 #include "sleep.h"
70 #include "timer.h"
71
72 struct suspend_context {
73         /*
74          * The next 7 values are referenced by offset in __restart_plls
75          * in headsmp-t2.S, and should not be moved
76          */
77         u32 pllx_misc;
78         u32 pllx_base;
79         u32 pllp_misc;
80         u32 pllp_base;
81         u32 pllp_outa;
82         u32 pllp_outb;
83         u32 pll_timeout;
84
85         u32 cpu_burst;
86         u32 clk_csite_src;
87         u32 cclk_divider;
88
89         u32 mc[3];
90         u8 uart[5];
91
92         struct tegra_twd_context twd;
93 };
94
95 #ifdef CONFIG_PM_SLEEP
96 #if USE_TEGRA_CPU_SUSPEND
97 void *tegra_cpu_context;        /* non-cacheable page for CPU context */
98 #endif
99 phys_addr_t tegra_pgd_phys;     /* pgd used by hotplug & LP2 bootup */
100 static pgd_t *tegra_pgd;
101 static DEFINE_SPINLOCK(tegra_lp2_lock);
102 static cpumask_t tegra_in_lp2;
103 static cpumask_t *iram_cpu_lp2_mask;
104 static u8 *iram_save;
105 static unsigned long iram_save_size;
106 static void __iomem *iram_code = IO_ADDRESS(TEGRA_IRAM_CODE_AREA);
107 static void __iomem *clk_rst = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
108 static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);
109 static int tegra_last_pclk;
110 #endif
111
112 struct suspend_context tegra_sctx;
113
114 #define TEGRA_POWER_PWRREQ_POLARITY     (1 << 8)   /* core power request polarity */
115 #define TEGRA_POWER_PWRREQ_OE           (1 << 9)   /* core power request enable */
116 #define TEGRA_POWER_SYSCLK_POLARITY     (1 << 10)  /* sys clk polarity */
117 #define TEGRA_POWER_SYSCLK_OE           (1 << 11)  /* system clock enable */
118 #define TEGRA_POWER_PWRGATE_DIS         (1 << 12)  /* power gate disabled */
119 #define TEGRA_POWER_EFFECT_LP0          (1 << 14)  /* enter LP0 when CPU pwr gated */
120 #define TEGRA_POWER_CPU_PWRREQ_POLARITY (1 << 15)  /* CPU power request polarity */
121 #define TEGRA_POWER_CPU_PWRREQ_OE       (1 << 16)  /* CPU power request enable */
122
123 #define PMC_CTRL                0x0
124 #define PMC_CTRL_LATCH_WAKEUPS  (1 << 5)
125 #define PMC_WAKE_MASK           0xc
126 #define PMC_WAKE_LEVEL          0x10
127 #define PMC_DPAD_ORIDE          0x1C
128 #define PMC_WAKE_DELAY          0xe0
129 #define PMC_DPD_SAMPLE          0x20
130
131 #define PMC_WAKE_STATUS         0x14
132 #define PMC_SW_WAKE_STATUS      0x18
133 #define PMC_COREPWRGOOD_TIMER   0x3c
134 #define PMC_SCRATCH0            0x50
135 #define PMC_SCRATCH1            0x54
136 #define PMC_CPUPWRGOOD_TIMER    0xc8
137 #define PMC_CPUPWROFF_TIMER     0xcc
138 #define PMC_COREPWROFF_TIMER    PMC_WAKE_DELAY
139
140 #define CLK_RESET_CCLK_BURST    0x20
141 #define CLK_RESET_CCLK_DIVIDER  0x24
142 #define CLK_RESET_PLLC_BASE     0x80
143 #define CLK_RESET_PLLM_BASE     0x90
144 #define CLK_RESET_PLLX_BASE     0xe0
145 #define CLK_RESET_PLLX_MISC     0xe4
146 #define CLK_RESET_PLLP_BASE     0xa0
147 #define CLK_RESET_PLLP_OUTA     0xa4
148 #define CLK_RESET_PLLP_OUTB     0xa8
149 #define CLK_RESET_PLLP_MISC     0xac
150
151 #define CLK_RESET_SOURCE_CSITE  0x1d4
152
153 #define CLK_RESET_CCLK_BURST_POLICY_SHIFT 28
154 #define CLK_RESET_CCLK_BURST_POLICY_PLLM   3
155 #define CLK_RESET_CCLK_BURST_POLICY_PLLX   8
156
157 #define EMC_MRW_0               0x0e8
158 #define EMC_MRW_DEV_SELECTN     30
159 #define EMC_MRW_DEV_NONE        (3 << EMC_MRW_DEV_SELECTN)
160
161 #define MC_SECURITY_START       0x6c
162 #define MC_SECURITY_SIZE        0x70
163 #define MC_SECURITY_CFG2        0x7c
164
165 static struct clk *tegra_pclk;
166 static const struct tegra_suspend_platform_data *pdata;
167 static enum tegra_suspend_mode current_suspend_mode = TEGRA_SUSPEND_NONE;
168
169 static const char *tegra_suspend_name[TEGRA_MAX_SUSPEND_MODE] = {
170         [TEGRA_SUSPEND_NONE]    = "none",
171         [TEGRA_SUSPEND_LP2]     = "lp2",
172         [TEGRA_SUSPEND_LP1]     = "lp1",
173         [TEGRA_SUSPEND_LP0]     = "lp0",
174 };
175
176 #if defined(CONFIG_TEGRA_CLUSTER_CONTROL) && INSTRUMENT_CLUSTER_SWITCH
177 enum tegra_cluster_switch_time_id {
178         tegra_cluster_switch_time_id_start = 0,
179         tegra_cluster_switch_time_id_prolog,
180         tegra_cluster_switch_time_id_switch,
181         tegra_cluster_switch_time_id_epilog,
182         tegra_cluster_switch_time_id_max
183 };
184
185 static unsigned long
186                 tegra_cluster_switch_times[tegra_cluster_switch_time_id_max];
187 #define tegra_cluster_switch_time(flags, id) \
188         do { \
189                 barrier(); \
190                 if (flags & TEGRA_POWER_CLUSTER_MASK) { \
191                         void __iomem *timer_us = \
192                                                 IO_ADDRESS(TEGRA_TMRUS_BASE); \
193                         if (id < tegra_cluster_switch_time_id_max) \
194                                 tegra_cluster_switch_times[id] = \
195                                                         readl(timer_us); \
196                                 wmb(); \
197                 } \
198                 barrier(); \
199         } while(0)
200 #else
201 #define tegra_cluster_switch_time(flags, id) do {} while(0)
202 #endif
203
204 #ifdef CONFIG_PM_SLEEP
205 unsigned long tegra_cpu_power_good_time(void)
206 {
207         if (WARN_ON_ONCE(!pdata))
208                 return 5000;
209
210         return pdata->cpu_timer;
211 }
212
213 unsigned long tegra_cpu_power_off_time(void)
214 {
215         if (WARN_ON_ONCE(!pdata))
216                 return 5000;
217
218         return pdata->cpu_off_timer;
219 }
220
221 unsigned long tegra_cpu_lp2_min_residency(void)
222 {
223         if (WARN_ON_ONCE(!pdata))
224                 return 2000;
225
226         return pdata->cpu_lp2_min_residency;
227 }
228
229 /*
230  * create_suspend_pgtable
231  *
232  * Creates a page table with identity mappings of physical memory and IRAM
233  * for use when the MMU is off, in addition to all the regular kernel mappings.
234  */
235 static __init int create_suspend_pgtable(void)
236 {
237         tegra_pgd = pgd_alloc(&init_mm);
238         if (!tegra_pgd)
239                 return -ENOMEM;
240
241         identity_mapping_add(tegra_pgd, phys_to_virt(PHYS_OFFSET),
242                 phys_to_virt(PHYS_OFFSET) + memblock_phys_mem_size(), 0);
243         identity_mapping_add(tegra_pgd, IO_IRAM_VIRT,
244                 IO_IRAM_VIRT + SECTION_SIZE, 0);
245
246         /* inner/outer write-back/write-allocate, sharable */
247         tegra_pgd_phys = (virt_to_phys(tegra_pgd) & PAGE_MASK) | 0x4A;
248
249         return 0;
250 }
251
252 /*
253  * alloc_suspend_context
254  *
255  * Allocate a non-cacheable page to hold the CPU contexts.
256  * The standard ARM CPU context save functions don't work if there's
257  * an external L2 cache controller (like a PL310) in system.
258  */
259 static __init int alloc_suspend_context(void)
260 {
261 #if USE_TEGRA_CPU_SUSPEND
262         pgprot_t prot = __pgprot_modify(pgprot_kernel, L_PTE_MT_MASK,
263                                         L_PTE_MT_BUFFERABLE | L_PTE_XN);
264         struct page *ctx_page;
265         unsigned long ctx_virt = 0;
266         pgd_t *pgd;
267         pmd_t *pmd;
268         pte_t *pte;
269
270         ctx_page = alloc_pages(GFP_KERNEL, 0);
271         if (IS_ERR_OR_NULL(ctx_page))
272                 goto fail;
273
274         tegra_cpu_context = vm_map_ram(&ctx_page, 1, -1, prot);
275         if (IS_ERR_OR_NULL(tegra_cpu_context))
276                 goto fail;
277
278         /* Add the context page to our private pgd. */
279         ctx_virt = (unsigned long)tegra_cpu_context;
280
281         pgd = tegra_pgd + pgd_index(ctx_virt);
282         if (!pgd_present(*pgd))
283                 goto fail;
284         pmd = pmd_offset(pgd, ctx_virt);
285         if (!pmd_none(*pmd))
286                 goto fail;
287         pte = pte_alloc_kernel(pmd, ctx_virt);
288         if (!pte)
289                 goto fail;
290
291         set_pte_ext(pte, mk_pte(ctx_page, prot), 0);
292
293         outer_clean_range(__pa(pmd), __pa(pmd + 1));
294
295         return 0;
296
297 fail:
298         if (ctx_page)
299                 __free_page(ctx_page);
300         if (ctx_virt)
301                 vm_unmap_ram((void*)ctx_virt, 1);
302         tegra_cpu_context = NULL;
303         return -ENOMEM;
304 #else
305         return 0;
306 #endif
307 }
308
309 /* ensures that sufficient time is passed for a register write to
310  * serialize into the 32KHz domain */
311 static void pmc_32kwritel(u32 val, unsigned long offs)
312 {
313         writel(val, pmc + offs);
314         udelay(130);
315 }
316
317 static void set_power_timers(unsigned long us_on, unsigned long us_off,
318                              long rate)
319 {
320         static unsigned long last_us_off = 0;
321         unsigned long long ticks;
322         unsigned long long pclk;
323
324         if (WARN_ON_ONCE(rate <= 0))
325                 pclk = 100000000;
326         else
327                 pclk = rate;
328
329         if ((rate != tegra_last_pclk) || (us_off != last_us_off)) {
330                 ticks = (us_on * pclk) + 999999ull;
331                 do_div(ticks, 1000000);
332                 writel((unsigned long)ticks, pmc + PMC_CPUPWRGOOD_TIMER);
333
334                 ticks = (us_off * pclk) + 999999ull;
335                 do_div(ticks, 1000000);
336                 writel((unsigned long)ticks, pmc + PMC_CPUPWROFF_TIMER);
337                 wmb();
338         }
339         tegra_last_pclk = pclk;
340         last_us_off = us_off;
341 }
342
343 /*
344  * restore_cpu_complex
345  *
346  * restores cpu clock setting, clears flow controller
347  *
348  * Always called on CPU 0.
349  */
350 static void restore_cpu_complex(u32 mode)
351 {
352         int cpu = smp_processor_id();
353         unsigned int reg;
354
355         BUG_ON(cpu != 0);
356
357         /* restore original PLL settings */
358         writel(tegra_sctx.pllx_misc, clk_rst + CLK_RESET_PLLX_MISC);
359         writel(tegra_sctx.pllx_base, clk_rst + CLK_RESET_PLLX_BASE);
360         writel(tegra_sctx.pllp_misc, clk_rst + CLK_RESET_PLLP_MISC);
361         writel(tegra_sctx.pllp_base, clk_rst + CLK_RESET_PLLP_BASE);
362         writel(tegra_sctx.pllp_outa, clk_rst + CLK_RESET_PLLP_OUTA);
363         writel(tegra_sctx.pllp_outb, clk_rst + CLK_RESET_PLLP_OUTB);
364
365         /* Is CPU complex already running on PLLX? */
366         reg = readl(clk_rst + CLK_RESET_CCLK_BURST);
367         reg &= 0xF;
368         if (reg != 0x8) {
369                 /* restore original burst policy setting; PLLX state restored
370                  * by CPU boot-up code - wait for PLL stabilization if PLLX
371                  * was enabled */
372
373                 reg = readl(clk_rst + CLK_RESET_PLLX_BASE);
374                 /* mask out bit 27 - not to check PLL lock bit */
375                 BUG_ON((reg & (~(1 << 27))) !=
376                                 (tegra_sctx.pllx_base & (~(1 << 27))));
377
378                 if (tegra_sctx.pllx_base & (1<<30)) {
379 #if USE_PLL_LOCK_BITS
380                         /* Enable lock detector */
381                         reg = readl(clk_rst + CLK_RESET_PLLX_MISC);
382                         reg |= 1<<18;
383                         writel(reg, clk_rst + CLK_RESET_PLLX_MISC);
384                         while (!(readl(clk_rst + CLK_RESET_PLLX_BASE) &&
385                                  (1<<27)))
386                                 cpu_relax();
387 #else
388                         udelay(300);
389 #endif
390                 }
391                 writel(tegra_sctx.cclk_divider, clk_rst +
392                        CLK_RESET_CCLK_DIVIDER);
393                 writel(tegra_sctx.cpu_burst, clk_rst +
394                        CLK_RESET_CCLK_BURST);
395         }
396
397         writel(tegra_sctx.clk_csite_src, clk_rst + CLK_RESET_SOURCE_CSITE);
398
399         /* Do not power-gate CPU 0 when flow controlled */
400         reg = flowctrl_read_cpu_csr(cpu);
401         reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
402         reg &= ~FLOW_CTRL_CSR_WFI_BITMAP;       /* clear wfi bitmap */
403         reg &= ~FLOW_CTRL_CSR_ENABLE;           /* clear enable */
404         reg |= FLOW_CTRL_CSR_INTR_FLAG;         /* clear intr */
405         reg |= FLOW_CTRL_CSR_EVENT_FLAG;        /* clear event */
406         flowctrl_write_cpu_csr(cpu, reg);
407
408         /* If an immedidate cluster switch is being perfomed, restore the
409            local timer registers. See save_cpu_complex() for the details. */
410         if (mode & (TEGRA_POWER_CLUSTER_MASK | TEGRA_POWER_CLUSTER_IMMEDIATE))
411                 tegra_twd_resume(&tegra_sctx.twd);
412 }
413
414 /*
415  * suspend_cpu_complex
416  *
417  * saves pll state for use by restart_plls, prepares flow controller for
418  * transition to suspend state
419  *
420  * Must always be called on cpu 0.
421  */
422 static void suspend_cpu_complex(u32 mode)
423 {
424         int cpu = smp_processor_id();
425         unsigned int reg;
426         int i;
427
428         BUG_ON(cpu != 0);
429
430         /* switch coresite to clk_m, save off original source */
431         tegra_sctx.clk_csite_src = readl(clk_rst + CLK_RESET_SOURCE_CSITE);
432         writel(3<<30, clk_rst + CLK_RESET_SOURCE_CSITE);
433
434         tegra_sctx.cpu_burst = readl(clk_rst + CLK_RESET_CCLK_BURST);
435         tegra_sctx.pllx_base = readl(clk_rst + CLK_RESET_PLLX_BASE);
436         tegra_sctx.pllx_misc = readl(clk_rst + CLK_RESET_PLLX_MISC);
437         tegra_sctx.pllp_base = readl(clk_rst + CLK_RESET_PLLP_BASE);
438         tegra_sctx.pllp_outa = readl(clk_rst + CLK_RESET_PLLP_OUTA);
439         tegra_sctx.pllp_outb = readl(clk_rst + CLK_RESET_PLLP_OUTB);
440         tegra_sctx.pllp_misc = readl(clk_rst + CLK_RESET_PLLP_MISC);
441         tegra_sctx.cclk_divider = readl(clk_rst + CLK_RESET_CCLK_DIVIDER);
442
443         /* If an immedidate cluster switch is being perfomed, save the
444            local timer registers. For calls resulting from CPU LP2 in
445            idle or system suspend, the local timer is shut down and
446            timekeeping switches over to the global system timer. */
447         if (mode & (TEGRA_POWER_CLUSTER_MASK | TEGRA_POWER_CLUSTER_IMMEDIATE))
448                 tegra_twd_suspend(&tegra_sctx.twd);
449
450         reg = flowctrl_read_cpu_csr(cpu);
451         reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
452         reg &= ~FLOW_CTRL_CSR_WFI_BITMAP;       /* clear wfi bitmap */
453         reg |= FLOW_CTRL_CSR_INTR_FLAG;         /* clear intr flag */
454         reg |= FLOW_CTRL_CSR_EVENT_FLAG;        /* clear event flag */
455 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
456         reg |= FLOW_CTRL_CSR_WFE_CPU0 << cpu;   /* enable power gating on wfe */
457 #else
458         reg |= FLOW_CTRL_CSR_WFI_CPU0 << cpu;   /* enable power gating on wfi */
459 #endif
460         reg |= FLOW_CTRL_CSR_ENABLE;            /* enable power gating */
461         flowctrl_write_cpu_csr(cpu, reg);
462
463         for (i = 0; i < num_possible_cpus(); i++) {
464                 if (i == cpu)
465                         continue;
466                 reg = flowctrl_read_cpu_csr(i);
467                 reg |= FLOW_CTRL_CSR_EVENT_FLAG;
468                 reg |= FLOW_CTRL_CSR_INTR_FLAG;
469                 flowctrl_write_cpu_csr(i, reg);
470         }
471
472         tegra_gic_cpu_disable();
473 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
474         /* Tegra3 enters LPx states via WFI - do not propagate legacy IRQs
475            to CPU core to avoid fall through WFI (IRQ-to-flow controller wake
476            path is not affected). */
477         tegra_gic_pass_through_disable();
478 #endif
479 }
480
481 void tegra_clear_cpu_in_lp2(int cpu)
482 {
483         spin_lock(&tegra_lp2_lock);
484         BUG_ON(!cpumask_test_cpu(cpu, &tegra_in_lp2));
485         cpumask_clear_cpu(cpu, &tegra_in_lp2);
486
487         /* Update the IRAM copy used by the reset handler. The IRAM copy
488            can't use used directly by cpumask_clear_cpu() because it uses
489            LDREX/STREX which requires the addressed location to be inner
490            cacheable and sharable which IRAM isn't. */
491         writel(tegra_in_lp2.bits[0], iram_cpu_lp2_mask);
492         dsb();
493
494         spin_unlock(&tegra_lp2_lock);
495 }
496
497 bool tegra_set_cpu_in_lp2(int cpu)
498 {
499         bool last_cpu = false;
500
501         spin_lock(&tegra_lp2_lock);
502         BUG_ON(cpumask_test_cpu(cpu, &tegra_in_lp2));
503         cpumask_set_cpu(cpu, &tegra_in_lp2);
504
505         /* Update the IRAM copy used by the reset handler. The IRAM copy
506            can't use used directly by cpumask_set_cpu() because it uses
507            LDREX/STREX which requires the addressed location to be inner
508            cacheable and sharable which IRAM isn't. */
509         writel(tegra_in_lp2.bits[0], iram_cpu_lp2_mask);
510         dsb();
511
512         if ((cpu == 0) && cpumask_equal(&tegra_in_lp2, cpu_online_mask))
513                 last_cpu = true;
514 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
515         else
516                 tegra2_cpu_set_resettable_soon();
517 #endif
518
519         spin_unlock(&tegra_lp2_lock);
520         return last_cpu;
521 }
522
523 unsigned int tegra_idle_lp2_last(unsigned int sleep_time, unsigned int flags)
524 {
525         u32 mode;       /* hardware + software power mode flags */
526         unsigned int remain;
527
528         /* Only the last cpu down does the final suspend steps */
529         mode = readl(pmc + PMC_CTRL);
530         mode |= TEGRA_POWER_CPU_PWRREQ_OE;
531         mode |= TEGRA_POWER_PWRREQ_OE;
532         mode &= ~TEGRA_POWER_EFFECT_LP0;
533         pmc_32kwritel(mode, PMC_CTRL);
534         mode |= flags;
535
536         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_start);
537
538         /*
539          * We can use clk_get_rate_all_locked() here, because all other cpus
540          * are in LP2 state and irqs are disabled
541          */
542         if (flags & TEGRA_POWER_CLUSTER_MASK) {
543                 set_power_timers(pdata->cpu_timer, 0,
544                         clk_get_rate_all_locked(tegra_pclk));
545                 tegra_cluster_switch_prolog(mode);
546         } else {
547                 set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer,
548                         clk_get_rate_all_locked(tegra_pclk));
549         }
550
551         if (sleep_time)
552                 tegra_lp2_set_trigger(sleep_time);
553
554         cpu_cluster_pm_enter();
555         suspend_cpu_complex(mode);
556         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_prolog);
557         flush_cache_all();
558         outer_flush_all();
559         outer_disable();
560
561         tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
562
563 #ifdef CONFIG_CACHE_L2X0
564         l2x0_enable();
565 #endif
566         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_switch);
567         restore_cpu_complex(mode);
568         cpu_cluster_pm_exit();
569
570         remain = tegra_lp2_timer_remain();
571         if (sleep_time)
572                 tegra_lp2_set_trigger(0);
573
574         if (flags & TEGRA_POWER_CLUSTER_MASK)
575                 tegra_cluster_switch_epilog(mode);
576
577         tegra_cluster_switch_time(flags, tegra_cluster_switch_time_id_epilog);
578
579 #if INSTRUMENT_CLUSTER_SWITCH
580         if (flags & TEGRA_POWER_CLUSTER_MASK) {
581                 pr_err("%s: prolog %lu us, switch %lu us, epilog %lu us, total %lu us\n",
582                         is_lp_cluster() ? "G=>LP" : "LP=>G",
583                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_prolog] -
584                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_start],
585                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_switch] -
586                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_prolog],
587                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_epilog] -
588                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_switch],
589                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_epilog] -
590                         tegra_cluster_switch_times[tegra_cluster_switch_time_id_start]);
591         }
592 #endif
593         return remain;
594 }
595
596 static int tegra_common_suspend(void)
597 {
598         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
599
600         tegra_sctx.mc[0] = readl(mc + MC_SECURITY_START);
601         tegra_sctx.mc[1] = readl(mc + MC_SECURITY_SIZE);
602         tegra_sctx.mc[2] = readl(mc + MC_SECURITY_CFG2);
603
604         /* copy the reset vector and SDRAM shutdown code into IRAM */
605         memcpy(iram_save, iram_code, iram_save_size);
606         memcpy(iram_code, tegra_iram_start(), iram_save_size);
607
608         return 0;
609 }
610
611 static void tegra_common_resume(void)
612 {
613         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
614 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
615         void __iomem *emc = IO_ADDRESS(TEGRA_EMC_BASE);
616 #endif
617
618         /* Clear DPD sample */
619         writel(0x0, pmc + PMC_DPD_SAMPLE);
620
621         writel(tegra_sctx.mc[0], mc + MC_SECURITY_START);
622         writel(tegra_sctx.mc[1], mc + MC_SECURITY_SIZE);
623         writel(tegra_sctx.mc[2], mc + MC_SECURITY_CFG2);
624 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
625         /* trigger emc mode write */
626         writel(EMC_MRW_DEV_NONE, emc + EMC_MRW_0);
627 #endif
628         /* clear scratch registers shared by suspend and the reset pen */
629         writel(0x0, pmc + PMC_SCRATCH39);
630         writel(0x0, pmc + PMC_SCRATCH41);
631
632         /* restore IRAM */
633         memcpy(iram_code, iram_save, iram_save_size);
634 }
635
636 static int tegra_suspend_prepare_late(void)
637 {
638 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
639         disable_irq(INT_SYS_STATS_MON);
640 #endif
641         return 0;
642 }
643
644 static void tegra_suspend_wake(void)
645 {
646 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
647         enable_irq(INT_SYS_STATS_MON);
648 #endif
649 }
650
651 static void tegra_pm_set(enum tegra_suspend_mode mode)
652 {
653         u32 reg, boot_flag;
654         unsigned long rate = 32768;
655
656         reg = readl(pmc + PMC_CTRL);
657         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
658         reg |= TEGRA_POWER_PWRREQ_OE;
659         reg &= ~TEGRA_POWER_EFFECT_LP0;
660
661         switch (mode) {
662         case TEGRA_SUSPEND_LP0:
663                 /*
664                  * LP0 boots through the AVP, which then resumes the AVP to
665                  * the address in scratch 39, and the cpu to the address in
666                  * scratch 41 to tegra_resume
667                  */
668                 writel(0x0, pmc + PMC_SCRATCH39);
669                 __raw_writel(virt_to_phys(tegra_resume), pmc + PMC_SCRATCH41);
670                 wmb();
671
672                 /* Enable DPD sample to trigger sampling pads data and direction
673                  * in which pad will be driven during lp0 mode*/
674                 writel(0x1, pmc + PMC_DPD_SAMPLE);
675
676                 /* Set warmboot flag */
677                 boot_flag = readl(pmc + PMC_SCRATCH0);
678                 pmc_32kwritel(boot_flag | 1, PMC_SCRATCH0);
679
680                 pmc_32kwritel(tegra_lp0_vec_start, PMC_SCRATCH1);
681
682                 reg |= TEGRA_POWER_EFFECT_LP0;
683                 break;
684         case TEGRA_SUSPEND_LP1:
685                 break;
686         case TEGRA_SUSPEND_LP2:
687                 rate = clk_get_rate(tegra_pclk);
688                 break;
689         case TEGRA_SUSPEND_NONE:
690                 return;
691         default:
692                 BUG();
693         }
694
695         set_power_timers(pdata->cpu_timer, pdata->cpu_off_timer, rate);
696
697         pmc_32kwritel(reg, PMC_CTRL);
698 }
699
700 static const char *lp_state[TEGRA_MAX_SUSPEND_MODE] = {
701         [TEGRA_SUSPEND_NONE] = "none",
702         [TEGRA_SUSPEND_LP2] = "LP2",
703         [TEGRA_SUSPEND_LP1] = "LP1",
704         [TEGRA_SUSPEND_LP0] = "LP0",
705 };
706
707 static int tegra_suspend_enter(suspend_state_t state)
708 {
709         int ret;
710
711         if (pdata && pdata->board_suspend)
712                 pdata->board_suspend(current_suspend_mode, TEGRA_SUSPEND_BEFORE_PERIPHERAL);
713
714         ret = tegra_suspend_dram(current_suspend_mode);
715
716         if (pdata && pdata->board_resume)
717                 pdata->board_resume(current_suspend_mode, TEGRA_RESUME_AFTER_PERIPHERAL);
718
719         return ret;
720 }
721
722 static void tegra_suspend_check_pwr_stats(void)
723 {
724         /* cpus and l2 are powered off later */
725         unsigned long pwrgate_partid_mask =
726 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC)
727                 (1 << TEGRA_POWERGATE_HEG)      |
728                 (1 << TEGRA_POWERGATE_SATA)     |
729                 (1 << TEGRA_POWERGATE_3D1)      |
730 #endif
731                 (1 << TEGRA_POWERGATE_3D)       |
732                 (1 << TEGRA_POWERGATE_VENC)     |
733                 (1 << TEGRA_POWERGATE_PCIE)     |
734                 (1 << TEGRA_POWERGATE_VDEC)     |
735                 (1 << TEGRA_POWERGATE_MPE);
736
737         int partid;
738
739         for_each_set_bit(partid, &pwrgate_partid_mask, BITS_PER_LONG)
740                 if (tegra_powergate_is_powered(partid) == 1)
741                         pr_warning("partition %s is left on before suspend\n",
742                                 tegra_powergate_get_name(partid));
743
744         return;
745 }
746
747 int tegra_suspend_dram(enum tegra_suspend_mode mode)
748 {
749         BUG_ON(mode < 0 || mode >= TEGRA_MAX_SUSPEND_MODE);
750
751         if ((mode == TEGRA_SUSPEND_LP0) && !tegra_pm_irq_lp0_allowed()) {
752                 pr_info("LP0 not used due to unsupported wakeup events\n");
753                 mode = TEGRA_SUSPEND_LP1;
754         }
755
756         if ((mode == TEGRA_SUSPEND_LP0) || (mode == TEGRA_SUSPEND_LP1))
757                 tegra_suspend_check_pwr_stats();
758
759         tegra_common_suspend();
760
761         pr_info("Entering suspend state %s\n", lp_state[mode]);
762
763         tegra_pm_set(mode);
764
765         if (pdata && pdata->board_suspend)
766                 pdata->board_suspend(mode, TEGRA_SUSPEND_BEFORE_CPU);
767
768         local_fiq_disable();
769
770         cpu_pm_enter();
771         cpu_cluster_pm_enter();
772
773         if (mode == TEGRA_SUSPEND_LP0) {
774                 tegra_lp0_cpu_mode(true);
775                 tegra_lp0_suspend_mc();
776         }
777
778         suspend_cpu_complex(0);
779         flush_cache_all();
780         outer_flush_all();
781         outer_disable();
782
783         if (mode == TEGRA_SUSPEND_LP2)
784                 tegra_sleep_cpu(PHYS_OFFSET - PAGE_OFFSET);
785         else
786                 tegra_sleep_core(PHYS_OFFSET - PAGE_OFFSET);
787
788         tegra_init_cache();
789
790         if (mode == TEGRA_SUSPEND_LP0) {
791                 tegra_lp0_resume_mc();
792                 tegra_lp0_cpu_mode(false);
793         }
794
795         restore_cpu_complex(0);
796
797         cpu_cluster_pm_exit();
798         cpu_pm_exit();
799
800         if (pdata && pdata->board_resume)
801                 pdata->board_resume(mode, TEGRA_RESUME_AFTER_CPU);
802
803         local_fiq_enable();
804
805         tegra_common_resume();
806
807         return 0;
808 }
809
810 /*
811  * Function pointers to optional board specific function
812  */
813 void (*tegra_deep_sleep)(int);
814 EXPORT_SYMBOL(tegra_deep_sleep);
815
816 static int tegra_suspend_prepare(void)
817 {
818         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
819                 tegra_deep_sleep(1);
820         return 0;
821 }
822
823 static void tegra_suspend_finish(void)
824 {
825         if ((current_suspend_mode == TEGRA_SUSPEND_LP0) && tegra_deep_sleep)
826                 tegra_deep_sleep(0);
827 }
828
829 static const struct platform_suspend_ops tegra_suspend_ops = {
830         .valid          = suspend_valid_only_mem,
831         .prepare        = tegra_suspend_prepare,
832         .finish         = tegra_suspend_finish,
833         .prepare_late   = tegra_suspend_prepare_late,
834         .wake           = tegra_suspend_wake,
835         .enter          = tegra_suspend_enter,
836 };
837
838 static ssize_t suspend_mode_show(struct kobject *kobj,
839                                         struct kobj_attribute *attr, char *buf)
840 {
841         char *start = buf;
842         char *end = buf + PAGE_SIZE;
843
844         start += scnprintf(start, end - start, "%s ", \
845                                 tegra_suspend_name[current_suspend_mode]);
846         start += scnprintf(start, end - start, "\n");
847
848         return start - buf;
849 }
850
851 static ssize_t suspend_mode_store(struct kobject *kobj,
852                                         struct kobj_attribute *attr,
853                                         const char *buf, size_t n)
854 {
855         int len;
856         const char *name_ptr;
857         enum tegra_suspend_mode new_mode;
858
859         name_ptr = buf;
860         while (*name_ptr && !isspace(*name_ptr))
861                 name_ptr++;
862         len = name_ptr - buf;
863         if (!len)
864                 goto bad_name;
865
866         for (new_mode = TEGRA_SUSPEND_NONE; \
867                         new_mode < TEGRA_MAX_SUSPEND_MODE; ++new_mode) {
868                 if (!strncmp(buf, tegra_suspend_name[new_mode], len)) {
869                         current_suspend_mode = new_mode;
870                         break;
871                 }
872         }
873
874 bad_name:
875         return n;
876 }
877
878 static struct kobj_attribute suspend_mode_attribute =
879         __ATTR(mode, 0644, suspend_mode_show, suspend_mode_store);
880
881 static struct kobject *suspend_kobj;
882 #endif
883
884 void __init tegra_init_suspend(struct tegra_suspend_platform_data *plat)
885 {
886         u32 reg;
887         u32 mode;
888
889         tegra_pclk = clk_get_sys(NULL, "pclk");
890         BUG_ON(IS_ERR(tegra_pclk));
891         pdata = plat;
892         (void)reg;
893         (void)mode;
894
895 #ifndef CONFIG_PM_SLEEP
896         if (plat->suspend_mode != TEGRA_SUSPEND_NONE) {
897                 pr_warning("%s: Suspend requires CONFIG_PM_SLEEP -- "
898                            "disabling suspend\n", __func__);
899                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
900         }
901 #else
902         if (create_suspend_pgtable() < 0) {
903                 pr_err("%s: PGD memory alloc failed -- LP0/LP1/LP2 unavailable\n",
904                                 __func__);
905                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
906                 goto fail;
907         }
908
909         if (alloc_suspend_context() < 0) {
910                 pr_err("%s: CPU context alloc failed -- LP0/LP1/LP2 unavailable\n",
911                                 __func__);
912                 plat->suspend_mode = TEGRA_SUSPEND_NONE;
913                 goto fail;
914         }
915
916         if ((tegra_chip_id == TEGRA30) &&
917             (tegra_revision == TEGRA_REVISION_A01) &&
918             (plat->suspend_mode == TEGRA_SUSPEND_LP0)) {
919                 /* Tegra 3 A01 supports only LP1 */
920                 pr_warning("%s: Suspend mode LP0 is not supported on A01 "
921                            "-- disabling LP0\n", __func__);
922                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
923         }
924         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && tegra_lp0_vec_size &&
925                 tegra_lp0_vec_relocate) {
926                 unsigned char *reloc_lp0;
927                 unsigned long tmp;
928                 void __iomem *orig;
929                 reloc_lp0 = kmalloc(tegra_lp0_vec_size + L1_CACHE_BYTES - 1,
930                                         GFP_KERNEL);
931                 WARN_ON(!reloc_lp0);
932                 if (!reloc_lp0) {
933                         pr_err("%s: Failed to allocate reloc_lp0\n",
934                                 __func__);
935                         goto out;
936                 }
937
938                 orig = ioremap(tegra_lp0_vec_start, tegra_lp0_vec_size);
939                 WARN_ON(!orig);
940                 if (!orig) {
941                         pr_err("%s: Failed to map tegra_lp0_vec_start %08lx\n",
942                                 __func__, tegra_lp0_vec_start);
943                         kfree(reloc_lp0);
944                         goto out;
945                 }
946
947                 tmp = (unsigned long) reloc_lp0;
948                 tmp = (tmp + L1_CACHE_BYTES - 1) & ~(L1_CACHE_BYTES - 1);
949                 reloc_lp0 = (unsigned char *)tmp;
950                 memcpy(reloc_lp0, orig, tegra_lp0_vec_size);
951                 iounmap(orig);
952                 tegra_lp0_vec_start = virt_to_phys(reloc_lp0);
953         }
954
955 out:
956         if (plat->suspend_mode == TEGRA_SUSPEND_LP0 && !tegra_lp0_vec_size) {
957                 pr_warning("%s: Suspend mode LP0 requested, no lp0_vec "
958                            "provided by bootlader -- disabling LP0\n",
959                            __func__);
960                 plat->suspend_mode = TEGRA_SUSPEND_LP1;
961         }
962
963         iram_save_size = tegra_iram_end() - tegra_iram_start();
964
965         iram_save = kmalloc(iram_save_size, GFP_KERNEL);
966         if (!iram_save && (plat->suspend_mode >= TEGRA_SUSPEND_LP1)) {
967                 pr_err("%s: unable to allocate memory for SDRAM self-refresh "
968                        "-- LP0/LP1 unavailable\n", __func__);
969                 plat->suspend_mode = TEGRA_SUSPEND_LP2;
970         }
971
972         /* !!!FIXME!!! THIS IS TEGRA2 ONLY */
973         /* Initialize scratch registers used for CPU LP2 synchronization */
974         writel(0, pmc + PMC_SCRATCH37);
975         writel(0, pmc + PMC_SCRATCH38);
976         writel(0, pmc + PMC_SCRATCH39);
977         writel(0, pmc + PMC_SCRATCH41);
978
979         /* Always enable CPU power request; just normal polarity is supported */
980         reg = readl(pmc + PMC_CTRL);
981         BUG_ON(reg & TEGRA_POWER_CPU_PWRREQ_POLARITY);
982         reg |= TEGRA_POWER_CPU_PWRREQ_OE;
983         pmc_32kwritel(reg, PMC_CTRL);
984
985         /* Configure core power request and system clock control if LP0
986            is supported */
987         __raw_writel(pdata->core_timer, pmc + PMC_COREPWRGOOD_TIMER);
988         __raw_writel(pdata->core_off_timer, pmc + PMC_COREPWROFF_TIMER);
989
990         reg = readl(pmc + PMC_CTRL);
991
992         if (!pdata->sysclkreq_high)
993                 reg |= TEGRA_POWER_SYSCLK_POLARITY;
994         else
995                 reg &= ~TEGRA_POWER_SYSCLK_POLARITY;
996
997         if (!pdata->corereq_high)
998                 reg |= TEGRA_POWER_PWRREQ_POLARITY;
999         else
1000                 reg &= ~TEGRA_POWER_PWRREQ_POLARITY;
1001
1002         /* configure output inverters while the request is tristated */
1003         pmc_32kwritel(reg, PMC_CTRL);
1004
1005         /* now enable requests */
1006         reg |= TEGRA_POWER_SYSCLK_OE;
1007         reg |= TEGRA_POWER_PWRREQ_OE;
1008         pmc_32kwritel(reg, PMC_CTRL);
1009
1010         if (pdata->suspend_mode == TEGRA_SUSPEND_LP0)
1011                 tegra_lp0_suspend_init();
1012
1013         suspend_set_ops(&tegra_suspend_ops);
1014
1015         /* Create /sys/power/suspend/type */
1016         suspend_kobj = kobject_create_and_add("suspend", power_kobj);
1017         if (suspend_kobj) {
1018                 if (sysfs_create_file(suspend_kobj, \
1019                                                 &suspend_mode_attribute.attr))
1020                         pr_err("%s: sysfs_create_file suspend type failed!\n",
1021                                                                 __func__);
1022         }
1023
1024         iram_cpu_lp2_mask = tegra_cpu_lp2_mask;
1025 fail:
1026 #endif
1027         if (plat->suspend_mode == TEGRA_SUSPEND_NONE)
1028                 tegra_lp2_in_idle(false);
1029
1030         current_suspend_mode = plat->suspend_mode;
1031 }
1032
1033 unsigned long debug_uart_port_base = 0;
1034 EXPORT_SYMBOL(debug_uart_port_base);
1035
1036 static int tegra_debug_uart_suspend(void)
1037 {
1038         void __iomem *uart;
1039         u32 lcr;
1040
1041         if (!debug_uart_port_base)
1042                 return 0;
1043
1044         uart = IO_ADDRESS(debug_uart_port_base);
1045
1046         lcr = readb(uart + UART_LCR * 4);
1047
1048         tegra_sctx.uart[0] = lcr;
1049         tegra_sctx.uart[1] = readb(uart + UART_MCR * 4);
1050
1051         /* DLAB = 0 */
1052         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1053
1054         tegra_sctx.uart[2] = readb(uart + UART_IER * 4);
1055
1056         /* DLAB = 1 */
1057         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1058
1059         tegra_sctx.uart[3] = readb(uart + UART_DLL * 4);
1060         tegra_sctx.uart[4] = readb(uart + UART_DLM * 4);
1061
1062         writeb(lcr, uart + UART_LCR * 4);
1063
1064         return 0;
1065 }
1066
1067 static void tegra_debug_uart_resume(void)
1068 {
1069         void __iomem *uart;
1070         u32 lcr;
1071
1072         if (!debug_uart_port_base)
1073                 return;
1074
1075         uart = IO_ADDRESS(debug_uart_port_base);
1076
1077         lcr = tegra_sctx.uart[0];
1078
1079         writeb(tegra_sctx.uart[1], uart + UART_MCR * 4);
1080
1081         /* DLAB = 0 */
1082         writeb(lcr & ~UART_LCR_DLAB, uart + UART_LCR * 4);
1083
1084         writeb(tegra_sctx.uart[2], uart + UART_IER * 4);
1085
1086         /* DLAB = 1 */
1087         writeb(lcr | UART_LCR_DLAB, uart + UART_LCR * 4);
1088
1089         writeb(tegra_sctx.uart[3], uart + UART_DLL * 4);
1090         writeb(tegra_sctx.uart[4], uart + UART_DLM * 4);
1091
1092         writeb(lcr, uart + UART_LCR * 4);
1093 }
1094
1095 static struct syscore_ops tegra_debug_uart_syscore_ops = {
1096         .suspend = tegra_debug_uart_suspend,
1097         .resume = tegra_debug_uart_resume,
1098 };
1099
1100 struct clk *debug_uart_clk = NULL;
1101 EXPORT_SYMBOL(debug_uart_clk);
1102
1103 void tegra_console_uart_suspend(void)
1104 {
1105         if (console_suspend_enabled && debug_uart_clk)
1106                 clk_disable(debug_uart_clk);
1107 }
1108
1109 void tegra_console_uart_resume(void)
1110 {
1111         if (console_suspend_enabled && debug_uart_clk)
1112                 clk_enable(debug_uart_clk);
1113 }
1114
1115 static int tegra_debug_uart_syscore_init(void)
1116 {
1117         register_syscore_ops(&tegra_debug_uart_syscore_ops);
1118         return 0;
1119 }
1120 arch_initcall(tegra_debug_uart_syscore_init);
1121
1122 #ifdef CONFIG_DEBUG_FS
1123 static int tegra_suspend_debug_show(struct seq_file *s, void *data)
1124 {
1125         seq_printf(s, "%s\n", tegra_suspend_name[*(int *)s->private]);
1126         return 0;
1127 }
1128
1129 static int tegra_suspend_debug_open(struct inode *inode, struct file *file)
1130 {
1131         return single_open(file, tegra_suspend_debug_show, inode->i_private);
1132 }
1133
1134 static int tegra_suspend_debug_write(struct file *file,
1135         const char __user *user_buf, size_t count, loff_t *ppos)
1136 {
1137         char buf[32];
1138         int buf_size;
1139         int i;
1140         struct seq_file *s = file->private_data;
1141         enum tegra_suspend_mode *val = s->private;
1142
1143         memset(buf, 0x00, sizeof(buf));
1144         buf_size = min(count, (sizeof(buf)-1));
1145         if (copy_from_user(buf, user_buf, buf_size))
1146                 return -EFAULT;
1147
1148         for (i = 0; i < TEGRA_MAX_SUSPEND_MODE; i++) {
1149                 if (!strnicmp(buf, tegra_suspend_name[i],
1150                     strlen(tegra_suspend_name[i]))) {
1151                         if (i > pdata->suspend_mode)
1152                                 return -EINVAL;
1153                         *val = i;
1154                         return count;
1155                 }
1156         }
1157
1158         return -EINVAL;
1159 }
1160
1161 static const struct file_operations tegra_suspend_debug_fops = {
1162         .open           = tegra_suspend_debug_open,
1163         .write          = tegra_suspend_debug_write,
1164         .read           = seq_read,
1165         .llseek         = seq_lseek,
1166         .release        = single_release,
1167 };
1168
1169 static int __init tegra_suspend_debug_init(void)
1170 {
1171         struct dentry *d;
1172
1173         d = debugfs_create_file("suspend_mode", 0755, NULL,
1174                 (void *)&current_suspend_mode, &tegra_suspend_debug_fops);
1175         if (!d) {
1176                 pr_info("Failed to create suspend_mode debug file\n");
1177                 return -ENOMEM;
1178         }
1179
1180         return 0;
1181 }
1182
1183 late_initcall(tegra_suspend_debug_init);
1184 #endif