]> git.sur5r.net Git - u-boot/blob - arch/arm/cpu/arm720t/tegra20/cpu.c
Tegra20: Move some include files to arch-tegra for sharing with Tegra30
[u-boot] / arch / arm / cpu / arm720t / tegra20 / cpu.c
1 /*
2 * (C) Copyright 2010-2011
3 * NVIDIA Corporation <www.nvidia.com>
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21 * MA 02111-1307 USA
22 */
23
24 #include <common.h>
25 #include <asm/io.h>
26 #include <asm/arch/clock.h>
27 #include <asm/arch/pinmux.h>
28 #include <asm/arch/tegra.h>
29 #include <asm/arch-tegra/clk_rst.h>
30 #include <asm/arch-tegra/pmc.h>
31 #include <asm/arch-tegra/scu.h>
32 #include "../tegra-common/cpu.h"
33
34 /* Returns 1 if the current CPU executing is a Cortex-A9, else 0 */
35 int ap20_cpu_is_cortexa9(void)
36 {
37         u32 id = readb(NV_PA_PG_UP_BASE + PG_UP_TAG_0);
38         return id == (PG_UP_TAG_0_PID_CPU & 0xff);
39 }
40
41 void init_pllx(void)
42 {
43         struct clk_rst_ctlr *clkrst = (struct clk_rst_ctlr *)NV_PA_CLK_RST_BASE;
44         struct clk_pll *pll = &clkrst->crc_pll[CLOCK_ID_XCPU];
45         u32 reg;
46
47         /* If PLLX is already enabled, just return */
48         if (readl(&pll->pll_base) & PLL_ENABLE_MASK)
49                 return;
50
51         /* Set PLLX_MISC */
52         writel(1 << PLL_CPCON_SHIFT, &pll->pll_misc);
53
54         /* Use 12MHz clock here */
55         reg = PLL_BYPASS_MASK | (12 << PLL_DIVM_SHIFT);
56         reg |= 1000 << PLL_DIVN_SHIFT;
57         writel(reg, &pll->pll_base);
58
59         reg |= PLL_ENABLE_MASK;
60         writel(reg, &pll->pll_base);
61
62         reg &= ~PLL_BYPASS_MASK;
63         writel(reg, &pll->pll_base);
64 }
65
66 static void enable_cpu_clock(int enable)
67 {
68         struct clk_rst_ctlr *clkrst = (struct clk_rst_ctlr *)NV_PA_CLK_RST_BASE;
69         u32 clk;
70
71         /*
72          * NOTE:
73          * Regardless of whether the request is to enable or disable the CPU
74          * clock, every processor in the CPU complex except the master (CPU 0)
75          * will have it's clock stopped because the AVP only talks to the
76          * master. The AVP does not know (nor does it need to know) that there
77          * are multiple processors in the CPU complex.
78          */
79
80         if (enable) {
81                 /* Initialize PLLX */
82                 init_pllx();
83
84                 /* Wait until all clocks are stable */
85                 udelay(PLL_STABILIZATION_DELAY);
86
87                 writel(CCLK_BURST_POLICY, &clkrst->crc_cclk_brst_pol);
88                 writel(SUPER_CCLK_DIVIDER, &clkrst->crc_super_cclk_div);
89         }
90
91         /*
92          * Read the register containing the individual CPU clock enables and
93          * always stop the clock to CPU 1.
94          */
95         clk = readl(&clkrst->crc_clk_cpu_cmplx);
96         clk |= 1 << CPU1_CLK_STP_SHIFT;
97
98         /* Stop/Unstop the CPU clock */
99         clk &= ~CPU0_CLK_STP_MASK;
100         clk |= !enable << CPU0_CLK_STP_SHIFT;
101         writel(clk, &clkrst->crc_clk_cpu_cmplx);
102
103         clock_enable(PERIPH_ID_CPU);
104 }
105
106 static int is_cpu_powered(void)
107 {
108         struct pmc_ctlr *pmc = (struct pmc_ctlr *)NV_PA_PMC_BASE;
109
110         return (readl(&pmc->pmc_pwrgate_status) & CPU_PWRED) ? 1 : 0;
111 }
112
113 static void remove_cpu_io_clamps(void)
114 {
115         struct pmc_ctlr *pmc = (struct pmc_ctlr *)NV_PA_PMC_BASE;
116         u32 reg;
117
118         /* Remove the clamps on the CPU I/O signals */
119         reg = readl(&pmc->pmc_remove_clamping);
120         reg |= CPU_CLMP;
121         writel(reg, &pmc->pmc_remove_clamping);
122
123         /* Give I/O signals time to stabilize */
124         udelay(IO_STABILIZATION_DELAY);
125 }
126
127 static void powerup_cpu(void)
128 {
129         struct pmc_ctlr *pmc = (struct pmc_ctlr *)NV_PA_PMC_BASE;
130         u32 reg;
131         int timeout = IO_STABILIZATION_DELAY;
132
133         if (!is_cpu_powered()) {
134                 /* Toggle the CPU power state (OFF -> ON) */
135                 reg = readl(&pmc->pmc_pwrgate_toggle);
136                 reg &= PARTID_CP;
137                 reg |= START_CP;
138                 writel(reg, &pmc->pmc_pwrgate_toggle);
139
140                 /* Wait for the power to come up */
141                 while (!is_cpu_powered()) {
142                         if (timeout-- == 0)
143                                 printf("CPU failed to power up!\n");
144                         else
145                                 udelay(10);
146                 }
147
148                 /*
149                  * Remove the I/O clamps from CPU power partition.
150                  * Recommended only on a Warm boot, if the CPU partition gets
151                  * power gated. Shouldn't cause any harm when called after a
152                  * cold boot according to HW, probably just redundant.
153                  */
154                 remove_cpu_io_clamps();
155         }
156 }
157
158 static void enable_cpu_power_rail(void)
159 {
160         struct pmc_ctlr *pmc = (struct pmc_ctlr *)NV_PA_PMC_BASE;
161         u32 reg;
162
163         reg = readl(&pmc->pmc_cntrl);
164         reg |= CPUPWRREQ_OE;
165         writel(reg, &pmc->pmc_cntrl);
166
167         /*
168          * The TI PMU65861C needs a 3.75ms delay between enabling
169          * the power rail and enabling the CPU clock.  This delay
170          * between SM1EN and SM1 is for switching time + the ramp
171          * up of the voltage to the CPU (VDD_CPU from PMU).
172          */
173         udelay(3750);
174 }
175
176 static void reset_A9_cpu(int reset)
177 {
178         /*
179         * NOTE:  Regardless of whether the request is to hold the CPU in reset
180         *        or take it out of reset, every processor in the CPU complex
181         *        except the master (CPU 0) will be held in reset because the
182         *        AVP only talks to the master. The AVP does not know that there
183         *        are multiple processors in the CPU complex.
184         */
185
186         /* Hold CPU 1 in reset, and CPU 0 if asked */
187         reset_cmplx_set_enable(1, crc_rst_cpu | crc_rst_de | crc_rst_debug, 1);
188         reset_cmplx_set_enable(0, crc_rst_cpu | crc_rst_de | crc_rst_debug,
189                                reset);
190
191         /* Enable/Disable master CPU reset */
192         reset_set_enable(PERIPH_ID_CPU, reset);
193 }
194
195 static void clock_enable_coresight(int enable)
196 {
197         u32 rst, src;
198
199         clock_set_enable(PERIPH_ID_CORESIGHT, enable);
200         reset_set_enable(PERIPH_ID_CORESIGHT, !enable);
201
202         if (enable) {
203                 /*
204                  * Put CoreSight on PLLP_OUT0 (216 MHz) and divide it down by
205                  *  1.5, giving an effective frequency of 144MHz.
206                  * Set PLLP_OUT0 [bits31:30 = 00], and use a 7.1 divisor
207                  *  (bits 7:0), so 00000001b == 1.5 (n+1 + .5)
208                  */
209                 src = CLK_DIVIDER(NVBL_PLLP_KHZ, 144000);
210                 clock_ll_set_source_divisor(PERIPH_ID_CSI, 0, src);
211
212                 /* Unlock the CPU CoreSight interfaces */
213                 rst = 0xC5ACCE55;
214                 writel(rst, CSITE_CPU_DBG0_LAR);
215                 writel(rst, CSITE_CPU_DBG1_LAR);
216         }
217 }
218
219 void start_cpu(u32 reset_vector)
220 {
221         /* Enable VDD_CPU */
222         enable_cpu_power_rail();
223
224         /* Hold the CPUs in reset */
225         reset_A9_cpu(1);
226
227         /* Disable the CPU clock */
228         enable_cpu_clock(0);
229
230         /* Enable CoreSight */
231         clock_enable_coresight(1);
232
233         /*
234          * Set the entry point for CPU execution from reset,
235          *  if it's a non-zero value.
236          */
237         if (reset_vector)
238                 writel(reset_vector, EXCEP_VECTOR_CPU_RESET_VECTOR);
239
240         /* Enable the CPU clock */
241         enable_cpu_clock(1);
242
243         /* If the CPU doesn't already have power, power it up */
244         powerup_cpu();
245
246         /* Take the CPU out of reset */
247         reset_A9_cpu(0);
248 }
249
250
251 void halt_avp(void)
252 {
253         for (;;) {
254                 writel((HALT_COP_EVENT_JTAG | HALT_COP_EVENT_IRQ_1 \
255                         | HALT_COP_EVENT_FIQ_1 | (FLOW_MODE_STOP<<29)),
256                         FLOW_CTLR_HALT_COP_EVENTS);
257         }
258 }