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