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