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