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