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