xloader: Panda - fix ROM OTG boot path
[x-loader:pandaboard-x-loader.git] / board / omap4430panda / clock.c
1 /*
2  * (C) Copyright 2009
3  * Texas Instruments, <www.ti.com>
4  * Richard Woodruff <r-woodruff2@ti.com>
5  * Rajendra Nayak <rnayak@ti.com>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation; either version 2 of
10  * the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20  * MA 02111-1307 USA
21  */
22
23 #include <common.h>
24 #include <asm/arch/cpu.h>
25 #include <asm/io.h>
26 #include <asm/arch/bits.h>
27 #include <asm/arch/clocks.h>
28 #include <asm/arch/mem.h>
29 #include <asm/arch/sys_proto.h>
30 #include <asm/arch/sys_info.h>
31 #include <asm/arch/clocks443x.h>
32 #include <command.h>
33
34 #define CONFIG_OMAP4_SDC 1
35
36 /* Used to index into DPLL parameter tables */
37 struct dpll_param {
38         unsigned int m;
39         unsigned int n;
40         unsigned int m2;
41         unsigned int m3;
42         unsigned int m4;
43         unsigned int m5;
44         unsigned int m6;
45         unsigned int m7;
46 };
47
48 /* Tables having M,N,M2 et al values for different sys_clk speeds
49  * This table is generated only for OPP100
50  * The tables are organized as follows:
51  * Rows : 1 - 12M, 2 - 13M, 3 - 16.8M, 4 - 19.2M, 5 - 26M, 6 - 27M, 7 - 38.4M
52  */
53
54 /* MPU parameters */
55 struct dpll_param mpu_dpll_param[7] = {
56         /* 12M values */
57         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
58         /* 13M values */
59         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
60         /* 16.8M values */
61         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
62         /* 19.2M values */
63         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
64         /* 26M values */
65         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
66         /* 27M values */
67         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
68         /* 38.4M values */
69 #ifdef CONFIG_MPU_600
70         /* RUN MPU @ 600 MHz */
71         {0x7d, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
72 #elif CONFIG_MPU_1000
73         {0x69, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
74 #else
75         {0x1a, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00},
76 #endif
77 };
78
79 /* IVA parameters */
80 struct dpll_param iva_dpll_param[7] = {
81         /* 12M values */
82         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
83         /* 13M values */
84         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
85         /* 16.8M values */
86         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
87         /* 19.2M values */
88         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
89         /* 26M values */
90         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
91         /* 27M values */
92         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
93         /* 38.4M values */
94 #ifdef CONFIG_OMAP4_SDC
95         {0x61, 0x03, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00},
96 #else
97         {0x61, 0x03, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00},
98 #endif
99 };
100
101 /* CORE parameters */
102 struct dpll_param core_dpll_param[7] = {
103         /* 12M values */
104         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
105         /* 13M values */
106         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
107         /* 16.8M values */
108         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
109         /* 19.2M values */
110         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
111         /* 26M values */
112         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
113         /* 27M values */
114         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
115         /* 38.4M values - DDR@200MHz*/
116         {0x7d, 0x05, 0x02, 0x05, 0x08, 0x04, 0x06, 0x05},
117 };
118
119 /* CORE parameters - ES2.1 */
120 struct dpll_param core_dpll_param_ddr400[7] = {
121         /* 12M values */
122         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
123         /* 13M values */
124         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
125         /* 16.8M values */
126         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
127         /* 19.2M values */
128         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
129         /* 26M values */
130         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
131         /* 27M values */
132         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
133         /* 38.4M values - DDR@400MHz*/
134         {0x7d, 0x05, 0x01, 0x05, 0x08, 0x04, 0x06, 0x05},
135 };
136
137 /* CORE parameters for L3 at 190 MHz - For ES1 only*/
138 struct dpll_param core_dpll_param_l3_190[7] = {
139         /* 12M values */
140         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
141         /* 13M values */
142         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
143         /* 16.8M values */
144         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
145         /* 19.2M values */
146         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
147         /* 26M values */
148         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
149         /* 27M values */
150         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
151         /* 38.4M values */
152 #ifdef CONFIG_OMAP4_SDC
153 #ifdef CORE_190MHZ
154         {0x1f0, 0x18, 0x01, 0x05, 0x08, 0x04, 0x06, 0x05},
155 #else /* Default CORE @166MHz */
156         {0x1b0, 0x18, 0x01, 0x05, 0x08, 0x04, 0x06, 0x05},
157 #endif
158 #else
159         {0x7d, 0x05, 0x01, 0x05, 0x08, 0x04, 0x06, 0x08},
160 #endif
161 };
162
163 /* PER parameters */
164 struct dpll_param per_dpll_param[7] = {
165         /* 12M values */
166         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
167         /* 13M values */
168         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
169         /* 16.8M values */
170         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
171         /* 19.2M values */
172         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
173         /* 26M values */
174         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
175         /* 27M values */
176         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
177         /* 38.4M values */
178 #if 0
179         /* SDC settings */
180         {0x0a, 0x00, 0x04, 0x03, 0x06, 0x05, 0x02, 0x03},
181 #endif
182         {0x14, 0x00, 0x08, 0x06, 0x0c, 0x09, 0x04, 0x05},
183 };
184
185 /* ABE parameters */
186 struct dpll_param abe_dpll_param[7] = {
187         /* 12M values */
188         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
189         /* 13M values */
190         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
191         /* 16.8M values */
192         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
193         /* 19.2M values */
194         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
195         /* 26M values */
196         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
197         /* 27M values */
198         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
199         /* 38.4M values */
200 #ifdef CONFIG_OMAP4_SDC
201         {0x40, 0x18, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0},
202 #else
203         {0x40, 0x18, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0},
204 #endif
205 };
206
207 /* USB parameters */
208 struct dpll_param usb_dpll_param[7] = {
209         /* 12M values */
210         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
211         /* 13M values */
212         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
213         /* 16.8M values */
214         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
215         /* 19.2M values */
216         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
217         /* 26M values */
218         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
219         /* 27M values */
220         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
221         /* 38.4M values */
222 #ifdef CONFIG_OMAP4_SDC
223         {0x32, 0x1, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0},
224 #else
225         {0x32, 0x1, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0},
226 #endif
227 };
228
229 static void configure_mpu_dpll(u32 clk_index)
230 {
231         struct dpll_param *dpll_param_p;
232
233         /* Unlock the MPU dpll */
234         sr32(CM_CLKMODE_DPLL_MPU, 0, 3, PLL_MN_POWER_BYPASS);
235         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_MPU, LDELAY);
236
237         /* Program MPU DPLL */
238         dpll_param_p = &mpu_dpll_param[clk_index];
239
240         sr32(CM_AUTOIDLE_DPLL_MPU, 0, 3, 0x0); /* Disable DPLL autoidle */
241
242         /* Set M,N,M2 values */
243         sr32(CM_CLKSEL_DPLL_MPU, 8, 11, dpll_param_p->m);
244         sr32(CM_CLKSEL_DPLL_MPU, 0, 6, dpll_param_p->n);
245         sr32(CM_DIV_M2_DPLL_MPU, 0, 5, dpll_param_p->m2);
246         sr32(CM_DIV_M2_DPLL_MPU, 8, 1, 0x1);
247
248         /* Lock the mpu dpll */
249         sr32(CM_CLKMODE_DPLL_MPU, 0, 3, PLL_LOCK | 0x10);
250         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_MPU, LDELAY);
251 }
252
253 static void configure_iva_dpll(u32 clk_index)
254 {
255         struct dpll_param *dpll_param_p;
256
257         /* Unlock the IVA dpll */
258         sr32(CM_CLKMODE_DPLL_IVA, 0, 3, PLL_MN_POWER_BYPASS);
259         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_IVA, LDELAY);
260
261         /* CM_BYPCLK_DPLL_IVA = CORE_X2_CLK/2 */
262         sr32(CM_BYPCLK_DPLL_IVA, 0, 2, 0x1);
263
264         /* Program IVA DPLL */
265         dpll_param_p = &iva_dpll_param[clk_index];
266
267         sr32(CM_AUTOIDLE_DPLL_IVA, 0, 3, 0x0); /* Disable DPLL autoidle */
268
269         /* Set M,N,M4,M5 */
270         sr32(CM_CLKSEL_DPLL_IVA, 8, 11, dpll_param_p->m);
271         sr32(CM_CLKSEL_DPLL_IVA, 0, 7, dpll_param_p->n);
272         sr32(CM_DIV_M4_DPLL_IVA, 0, 5, dpll_param_p->m4);
273         sr32(CM_DIV_M4_DPLL_IVA, 8, 1, 0x1);
274         sr32(CM_DIV_M5_DPLL_IVA, 0, 5, dpll_param_p->m5);
275         sr32(CM_DIV_M5_DPLL_IVA, 8, 1, 0x1);
276
277         /* Lock the iva dpll */
278         sr32(CM_CLKMODE_DPLL_IVA, 0, 3, PLL_LOCK);
279         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_IVA, LDELAY);
280 }
281
282 static void configure_per_dpll(u32 clk_index)
283 {
284         struct dpll_param *dpll_param_p;
285
286         /* Unlock the PER dpll */
287         sr32(CM_CLKMODE_DPLL_PER, 0, 3, PLL_MN_POWER_BYPASS);
288         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_PER, LDELAY);
289
290         /* Program PER DPLL */
291         dpll_param_p = &per_dpll_param[clk_index];
292
293         /* Disable autoidle */
294         sr32(CM_AUTOIDLE_DPLL_PER, 0, 3, 0x0);
295
296         sr32(CM_CLKSEL_DPLL_PER, 8, 11, dpll_param_p->m);
297         sr32(CM_CLKSEL_DPLL_PER, 0, 6, dpll_param_p->n);
298         sr32(CM_DIV_M2_DPLL_PER, 0, 5, dpll_param_p->m2);
299         sr32(CM_DIV_M3_DPLL_PER, 0, 5, dpll_param_p->m3);
300         sr32(CM_DIV_M4_DPLL_PER, 0, 5, dpll_param_p->m4);
301         sr32(CM_DIV_M5_DPLL_PER, 0, 5, dpll_param_p->m5);
302         sr32(CM_DIV_M6_DPLL_PER, 0, 5, dpll_param_p->m6);
303         sr32(CM_DIV_M7_DPLL_PER, 0, 5, dpll_param_p->m7);
304
305
306         sr32(CM_DIV_M2_DPLL_PER, 8, 1, 0x1);
307         sr32(CM_DIV_M3_DPLL_PER, 8, 1, 0x1);
308         sr32(CM_DIV_M4_DPLL_PER, 8, 1, 0x1);
309         sr32(CM_DIV_M5_DPLL_PER, 8, 1, 0x1);
310         sr32(CM_DIV_M6_DPLL_PER, 8, 1, 0x1);
311         sr32(CM_DIV_M7_DPLL_PER, 8, 1, 0x1);
312
313         /* Lock the per dpll */
314         sr32(CM_CLKMODE_DPLL_PER, 0, 3, PLL_LOCK);
315         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_PER, LDELAY);
316 }
317
318 static void configure_abe_dpll(u32 clk_index)
319 {
320         struct dpll_param *dpll_param_p;
321
322         /* Select sys_clk as ref clk for ABE dpll */
323         sr32(CM_ABE_PLL_REF_CLKSEL, 0, 32, 0x0);
324
325         /* Enable slimbus and pad clocks */
326         sr32(CM_CLKSEL_ABE, 0, 32, 0x500);
327
328         /* Unlock the ABE dpll */
329         sr32(CM_CLKMODE_DPLL_ABE, 0, 3, PLL_MN_POWER_BYPASS);
330         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_ABE, LDELAY);
331
332         /* Program ABE DPLL */
333         dpll_param_p = &abe_dpll_param[clk_index];
334
335         /* Disable autoidle */
336         sr32(CM_AUTOIDLE_DPLL_ABE, 0, 3, 0x0);
337
338         sr32(CM_CLKSEL_DPLL_ABE, 8, 11, dpll_param_p->m);
339         sr32(CM_CLKSEL_DPLL_ABE, 0, 6, dpll_param_p->n);
340
341         /* Force DPLL CLKOUTHIF to stay enabled */
342         sr32(CM_DIV_M2_DPLL_ABE, 0, 32, 0x500);
343         sr32(CM_DIV_M2_DPLL_ABE, 0, 5, dpll_param_p->m2);
344         sr32(CM_DIV_M2_DPLL_ABE, 8, 1, 0x1);
345         /* Force DPLL CLKOUTHIF to stay enabled */
346         sr32(CM_DIV_M3_DPLL_ABE, 0, 32, 0x100);
347         sr32(CM_DIV_M3_DPLL_ABE, 0, 5, dpll_param_p->m3);
348         sr32(CM_DIV_M3_DPLL_ABE, 8, 1, 0x1);
349
350         /* Lock the abe dpll */
351         sr32(CM_CLKMODE_DPLL_ABE, 0, 3, PLL_LOCK);
352         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_ABE, LDELAY);
353 }
354
355 static void configure_usb_dpll(u32 clk_index)
356 {
357         struct dpll_param *dpll_param_p;
358
359         /* Select the 60Mhz clock 480/8 = 60*/
360         sr32(CM_CLKSEL_USB_60MHz, 0, 32, 0x1);
361
362         /* Unlock the USB dpll */
363         sr32(CM_CLKMODE_DPLL_USB, 0, 3, PLL_MN_POWER_BYPASS);
364         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_USB, LDELAY);
365
366         /* Program USB DPLL */
367         dpll_param_p = &usb_dpll_param[clk_index];
368
369         /* Disable autoidle */
370         sr32(CM_AUTOIDLE_DPLL_USB, 0, 3, 0x0);
371
372         sr32(CM_CLKSEL_DPLL_USB, 8, 11, dpll_param_p->m);
373         sr32(CM_CLKSEL_DPLL_USB, 0, 6, dpll_param_p->n);
374
375         /* Force DPLL CLKOUT to stay active */
376         sr32(CM_DIV_M2_DPLL_USB, 0, 32, 0x100);
377         sr32(CM_DIV_M2_DPLL_USB, 0, 5, dpll_param_p->m2);
378         sr32(CM_DIV_M2_DPLL_USB, 8, 1, 0x1);
379         sr32(CM_CLKDCOLDO_DPLL_USB, 8, 1, 0x1);
380
381         /* Lock the usb dpll */
382         sr32(CM_CLKMODE_DPLL_USB, 0, 3, PLL_LOCK);
383         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_USB, LDELAY);
384
385         /* force enable the CLKDCOLDO clock */
386         sr32(CM_CLKDCOLDO_DPLL_USB, 0, 32, 0x100);
387 }
388
389 #if 0
390
391 /* to remove warning about unused function; will be deleted in decruft patch */
392 static void configure_core_dpll(int clk_index)
393 {
394         struct dpll_param *dpll_param_p;
395
396         /* Get the sysclk speed from cm_sys_clksel
397          * Set it to 38.4 MHz, in case ROM code is bypassed
398          */
399         if (!clk_index)
400                 return;
401
402         /* CORE_CLK=CORE_X2_CLK/2, L3_CLK=CORE_CLK/2, L4_CLK=L3_CLK/2 */
403         sr32(CM_CLKSEL_CORE, 0, 32, 0x110);
404
405         /* Unlock the CORE dpll */
406         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_MN_POWER_BYPASS);
407         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_CORE, LDELAY);
408
409         /* Program Core DPLL */
410         switch (omap_revision()) {
411         case OMAP4430_ES1_0:
412                 dpll_param_p = &core_dpll_param_l3_190[clk_index];
413                 break;
414         case OMAP4430_ES2_0:
415                 dpll_param_p = &core_dpll_param[clk_index];
416                 break;
417         case OMAP4430_ES2_1:
418                 dpll_param_p = &core_dpll_param_ddr400[clk_index];
419                 break;
420         }
421
422         /* Disable autoidle */
423         sr32(CM_AUTOIDLE_DPLL_CORE, 0, 3, 0x0);
424
425         sr32(CM_CLKSEL_DPLL_CORE, 8, 11, dpll_param_p->m);
426         sr32(CM_CLKSEL_DPLL_CORE, 0, 6, dpll_param_p->n);
427         sr32(CM_DIV_M2_DPLL_CORE, 0, 5, dpll_param_p->m2);
428         sr32(CM_DIV_M3_DPLL_CORE, 0, 5, dpll_param_p->m3);
429         sr32(CM_DIV_M4_DPLL_CORE, 0, 5, dpll_param_p->m4);
430         sr32(CM_DIV_M5_DPLL_CORE, 0, 5, dpll_param_p->m5);
431         sr32(CM_DIV_M6_DPLL_CORE, 0, 5, dpll_param_p->m6);
432         sr32(CM_DIV_M7_DPLL_CORE, 0, 5, dpll_param_p->m7);
433
434         if (omap_revision() == OMAP4430_ES1_0) {
435                 /* Do this only on ES1.0 */
436                 sr32(CM_DIV_M2_DPLL_CORE, 8, 1, 0x1);
437                 sr32(CM_DIV_M3_DPLL_CORE, 8, 1, 0x1);
438                 sr32(CM_DIV_M4_DPLL_CORE, 8, 1, 0x1);
439                 sr32(CM_DIV_M5_DPLL_CORE, 8, 1, 0x1);
440                 sr32(CM_DIV_M6_DPLL_CORE, 8, 1, 0x0);
441                 sr32(CM_DIV_M7_DPLL_CORE, 8, 1, 0x1);
442         }
443
444         /* Lock the core dpll */
445         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_LOCK);
446         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_CORE, LDELAY);
447 }
448 #endif
449
450 void configure_core_dpll_no_lock(void)
451 {
452         struct dpll_param *dpll_param_p = NULL;
453         u32 clk_index;
454
455         /* Get the sysclk speed from cm_sys_clksel
456          * Set it to 38.4 MHz, in case ROM code is bypassed
457          */
458         __raw_writel(0x7, CM_SYS_CLKSEL);
459         clk_index = 7;
460
461         clk_index = clk_index - 1;
462         /* CORE_CLK=CORE_X2_CLK/2, L3_CLK=CORE_CLK/2, L4_CLK=L3_CLK/2 */
463         sr32(CM_CLKSEL_CORE, 0, 32, 0x110);
464
465         /* Unlock the CORE dpll */
466         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_MN_POWER_BYPASS);
467         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_CORE, LDELAY);
468
469         /* Program Core DPLL */
470         switch (omap_revision()) {
471         case OMAP4430_ES1_0:
472                 dpll_param_p = &core_dpll_param_l3_190[clk_index];
473                 break;
474         case OMAP4430_ES2_0:
475                 dpll_param_p = &core_dpll_param[clk_index];
476                 break;
477         case OMAP4430_ES2_1:
478                 dpll_param_p = &core_dpll_param_ddr400[clk_index];
479                 break;
480         default:
481                 /* we are screwed */
482                 break;
483         }
484
485         /* Disable autoidle */
486         sr32(CM_AUTOIDLE_DPLL_CORE, 0, 3, 0x0);
487
488         sr32(CM_CLKSEL_DPLL_CORE, 8, 11, dpll_param_p->m);
489         sr32(CM_CLKSEL_DPLL_CORE, 0, 6, dpll_param_p->n);
490         sr32(CM_DIV_M2_DPLL_CORE, 0, 5, dpll_param_p->m2);
491         sr32(CM_DIV_M3_DPLL_CORE, 0, 5, dpll_param_p->m3);
492         sr32(CM_DIV_M4_DPLL_CORE, 0, 5, dpll_param_p->m4);
493         sr32(CM_DIV_M5_DPLL_CORE, 0, 5, dpll_param_p->m5);
494         sr32(CM_DIV_M6_DPLL_CORE, 0, 5, dpll_param_p->m6);
495         sr32(CM_DIV_M7_DPLL_CORE, 0, 5, dpll_param_p->m7);
496
497         sr32(CM_DIV_M2_DPLL_CORE, 8, 1, 0x1);
498         sr32(CM_DIV_M3_DPLL_CORE, 8, 1, 0x1);
499         sr32(CM_DIV_M4_DPLL_CORE, 8, 1, 0x1);
500         sr32(CM_DIV_M5_DPLL_CORE, 8, 1, 0x1);
501         sr32(CM_DIV_M6_DPLL_CORE, 8, 1, 0x0);
502         sr32(CM_DIV_M7_DPLL_CORE, 8, 1, 0x1);
503 }
504
505 void lock_core_dpll(void)
506 {
507         /* Lock the core dpll */
508         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_LOCK);
509         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_CORE, LDELAY);
510 }
511
512 void lock_core_dpll_shadow(void)
513 {
514         struct dpll_param *dpll_param_p = NULL;
515
516         /* Lock the core dpll using freq update method */
517         __raw_writel(10, 0x4A004120); /* CM_CLKMODE_DPLL_CORE */
518
519         switch (omap_revision()) {
520         case OMAP4430_ES1_0:
521                 dpll_param_p = &core_dpll_param_l3_190[6];
522                 break;
523         case OMAP4430_ES2_0:
524                 dpll_param_p = &core_dpll_param[6];
525                 break;
526         case OMAP4430_ES2_1:
527                 dpll_param_p = &core_dpll_param_ddr400[6];
528                 break;
529         default:
530                 /* we are screwed */
531                 break;
532         }
533
534         /* CM_SHADOW_FREQ_CONFIG1: DLL_OVERRIDE = 1(hack), DLL_RESET = 1,
535          * DPLL_CORE_M2_DIV =1, DPLL_CORE_DPLL_EN = 0x7, FREQ_UPDATE = 1
536          */
537         __raw_writel(0x70D | (dpll_param_p->m2 << 11), 0x4A004260);
538
539         /*
540          * if the EMIF never goes idle, and eg, if ROM enabled USB,
541          * we loop for a very very long time here becuse shadow updates wait
542          * until EMIF idle
543          */
544
545         /* Wait for Freq_Update to get cleared: CM_SHADOW_FREQ_CONFIG1 */
546         while (__raw_readl(0x4A004260) & 1)
547                 ;
548
549         /* Wait for DPLL to Lock : CM_IDLEST_DPLL_CORE */
550         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_CORE, LDELAY);
551         /* lock_core_dpll(); */
552 }
553
554 static void enable_all_clocks(void)
555 {
556         /* Enable Ducati clocks */
557         sr32(CM_DUCATI_DUCATI_CLKCTRL, 0, 32, 0x1);
558         sr32(CM_DUCATI_CLKSTCTRL, 0, 32, 0x2);
559
560         wait_on_value(BIT8, BIT8, CM_DUCATI_CLKSTCTRL, LDELAY);
561
562         /* Enable ivahd and sl2 clocks */
563         sr32(IVAHD_IVAHD_CLKCTRL, 0, 32, 0x1);
564         sr32(IVAHD_SL2_CLKCTRL, 0, 32, 0x1);
565         sr32(IVAHD_CLKSTCTRL, 0, 32, 0x2);
566
567         wait_on_value(BIT8, BIT8, IVAHD_CLKSTCTRL, LDELAY);
568
569         /* Enable Tesla clocks */
570         sr32(DSP_DSP_CLKCTRL, 0, 32, 0x1);
571         sr32(DSP_CLKSTCTRL, 0, 32, 0x2);
572
573         wait_on_value(BIT8, BIT8, DSP_CLKSTCTRL, LDELAY);
574
575         /* wait for tesla to become accessible */
576
577         /* ABE clocks */
578         sr32(CM1_ABE_CLKSTCTRL, 0, 32, 0x3);
579         sr32(CM1_ABE_AESS_CLKCTRL, 0, 32, 0x2);
580         sr32(CM1_ABE_PDM_CLKCTRL, 0, 32, 0x2);
581         sr32(CM1_ABE_DMIC_CLKCTRL, 0, 32, 0x2);
582         sr32(CM1_ABE_MCASP_CLKCTRL, 0, 32, 0x2);
583         sr32(CM1_ABE_MCBSP1_CLKCTRL, 0, 32, 0x08000002);
584         sr32(CM1_ABE_MCBSP2_CLKCTRL, 0, 32, 0x08000002);
585         sr32(CM1_ABE_MCBSP3_CLKCTRL, 0, 32, 0x08000002);
586         sr32(CM1_ABE_SLIMBUS_CLKCTRL, 0, 32, 0xf02);
587         sr32(CM1_ABE_TIMER5_CLKCTRL, 0, 32, 0x2);
588         sr32(CM1_ABE_TIMER6_CLKCTRL, 0, 32, 0x2);
589         sr32(CM1_ABE_TIMER7_CLKCTRL, 0, 32, 0x2);
590         sr32(CM1_ABE_TIMER8_CLKCTRL, 0, 32, 0x2);
591         sr32(CM1_ABE_WDT3_CLKCTRL, 0, 32, 0x2);
592         /* Disable sleep transitions */
593         sr32(CM1_ABE_CLKSTCTRL, 0, 32, 0x0);
594
595         /* L4PER clocks */
596         sr32(CM_L4PER_CLKSTCTRL, 0, 32, 0x2);
597         sr32(CM_L4PER_DMTIMER10_CLKCTRL, 0, 32, 0x2);
598         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER10_CLKCTRL, LDELAY);
599         sr32(CM_L4PER_DMTIMER11_CLKCTRL, 0, 32, 0x2);
600         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER11_CLKCTRL, LDELAY);
601         sr32(CM_L4PER_DMTIMER2_CLKCTRL, 0, 32, 0x2);
602         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER2_CLKCTRL, LDELAY);
603         sr32(CM_L4PER_DMTIMER3_CLKCTRL, 0, 32, 0x2);
604         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER3_CLKCTRL, LDELAY);
605         sr32(CM_L4PER_DMTIMER4_CLKCTRL, 0, 32, 0x2);
606         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER4_CLKCTRL, LDELAY);
607         sr32(CM_L4PER_DMTIMER9_CLKCTRL, 0, 32, 0x2);
608         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER9_CLKCTRL, LDELAY);
609
610         /* GPIO clocks */
611         sr32(CM_L4PER_GPIO2_CLKCTRL, 0, 32, 0x1);
612         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO2_CLKCTRL, LDELAY);
613         sr32(CM_L4PER_GPIO3_CLKCTRL, 0, 32, 0x1);
614         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO3_CLKCTRL, LDELAY);
615         sr32(CM_L4PER_GPIO4_CLKCTRL, 0, 32, 0x1);
616         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO4_CLKCTRL, LDELAY);
617         sr32(CM_L4PER_GPIO5_CLKCTRL, 0, 32, 0x1);
618         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO5_CLKCTRL, LDELAY);
619         sr32(CM_L4PER_GPIO6_CLKCTRL, 0, 32, 0x1);
620         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO6_CLKCTRL, LDELAY);
621
622         sr32(CM_L4PER_HDQ1W_CLKCTRL, 0, 32, 0x2);
623
624         /* I2C clocks */
625         sr32(CM_L4PER_I2C1_CLKCTRL, 0, 32, 0x2);
626         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C1_CLKCTRL, LDELAY);
627         sr32(CM_L4PER_I2C2_CLKCTRL, 0, 32, 0x2);
628         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C2_CLKCTRL, LDELAY);
629         sr32(CM_L4PER_I2C3_CLKCTRL, 0, 32, 0x2);
630         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C3_CLKCTRL, LDELAY);
631         sr32(CM_L4PER_I2C4_CLKCTRL, 0, 32, 0x2);
632         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C4_CLKCTRL, LDELAY);
633
634         sr32(CM_L4PER_MCBSP4_CLKCTRL, 0, 32, 0x2);
635         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCBSP4_CLKCTRL, LDELAY);
636
637         /* MCSPI clocks */
638         sr32(CM_L4PER_MCSPI1_CLKCTRL, 0, 32, 0x2);
639         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI1_CLKCTRL, LDELAY);
640         sr32(CM_L4PER_MCSPI2_CLKCTRL, 0, 32, 0x2);
641         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI2_CLKCTRL, LDELAY);
642         sr32(CM_L4PER_MCSPI3_CLKCTRL, 0, 32, 0x2);
643         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI3_CLKCTRL, LDELAY);
644         sr32(CM_L4PER_MCSPI4_CLKCTRL, 0, 32, 0x2);
645         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI4_CLKCTRL, LDELAY);
646
647         /* MMC clocks */
648         sr32(CM_L3INIT_HSMMC1_CLKCTRL, 0, 2, 0x2);
649         sr32(CM_L3INIT_HSMMC1_CLKCTRL, 24, 1, 0x1);
650         sr32(CM_L3INIT_HSMMC2_CLKCTRL, 0, 2, 0x2);
651         sr32(CM_L3INIT_HSMMC2_CLKCTRL, 24, 1, 0x1);
652         sr32(CM_L4PER_MMCSD3_CLKCTRL, 0, 32, 0x2);
653         wait_on_value(BIT18|BIT17|BIT16, 0, CM_L4PER_MMCSD3_CLKCTRL, LDELAY);
654         sr32(CM_L4PER_MMCSD4_CLKCTRL, 0, 32, 0x2);
655         wait_on_value(BIT18|BIT17|BIT16, 0, CM_L4PER_MMCSD4_CLKCTRL, LDELAY);
656         sr32(CM_L4PER_MMCSD5_CLKCTRL, 0, 32, 0x2);
657         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MMCSD5_CLKCTRL, LDELAY);
658
659         /* UART clocks */
660         sr32(CM_L4PER_UART1_CLKCTRL, 0, 32, 0x2);
661         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART1_CLKCTRL, LDELAY);
662         sr32(CM_L4PER_UART2_CLKCTRL, 0, 32, 0x2);
663         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART2_CLKCTRL, LDELAY);
664         sr32(CM_L4PER_UART3_CLKCTRL, 0, 32, 0x2);
665         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART3_CLKCTRL, LDELAY);
666         sr32(CM_L4PER_UART4_CLKCTRL, 0, 32, 0x2);
667         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART4_CLKCTRL, LDELAY);
668
669         /* WKUP clocks */
670         sr32(CM_WKUP_GPIO1_CLKCTRL, 0, 32, 0x1);
671         wait_on_value(BIT17|BIT16, 0, CM_WKUP_GPIO1_CLKCTRL, LDELAY);
672         sr32(CM_WKUP_TIMER1_CLKCTRL, 0, 32, 0x01000002);
673         wait_on_value(BIT17|BIT16, 0, CM_WKUP_TIMER1_CLKCTRL, LDELAY);
674
675         sr32(CM_WKUP_KEYBOARD_CLKCTRL, 0, 32, 0x2);
676         wait_on_value(BIT17|BIT16, 0, CM_WKUP_KEYBOARD_CLKCTRL, LDELAY);
677
678         sr32(CM_SDMA_CLKSTCTRL, 0, 32, 0x0);
679         sr32(CM_MEMIF_CLKSTCTRL, 0, 32, 0x3);
680         sr32(CM_MEMIF_EMIF_1_CLKCTRL, 0, 32, 0x1);
681         wait_on_value(BIT17|BIT16, 0, CM_MEMIF_EMIF_1_CLKCTRL, LDELAY);
682         sr32(CM_MEMIF_EMIF_2_CLKCTRL, 0, 32, 0x1);
683         wait_on_value(BIT17|BIT16, 0, CM_MEMIF_EMIF_2_CLKCTRL, LDELAY);
684         sr32(CM_D2D_CLKSTCTRL, 0, 32, 0x3);
685         sr32(CM_L3_2_GPMC_CLKCTRL, 0, 32, 0x1);
686         wait_on_value(BIT17|BIT16, 0, CM_L3_2_GPMC_CLKCTRL, LDELAY);
687         sr32(CM_L3INSTR_L3_3_CLKCTRL, 0, 32, 0x1);
688         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_L3_3_CLKCTRL, LDELAY);
689         sr32(CM_L3INSTR_L3_INSTR_CLKCTRL, 0, 32, 0x1);
690         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_L3_INSTR_CLKCTRL, LDELAY);
691         sr32(CM_L3INSTR_OCP_WP1_CLKCTRL, 0, 32, 0x1);
692         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_OCP_WP1_CLKCTRL, LDELAY);
693
694         /* WDT clocks */
695         sr32(CM_WKUP_WDT2_CLKCTRL, 0, 32, 0x2);
696         wait_on_value(BIT17|BIT16, 0, CM_WKUP_WDT2_CLKCTRL, LDELAY);
697
698         /* Enable Camera clocks */
699         sr32(CM_CAM_CLKSTCTRL, 0, 32, 0x3);
700         sr32(CM_CAM_ISS_CLKCTRL, 0, 32, 0x102);
701         sr32(CM_CAM_FDIF_CLKCTRL, 0, 32, 0x2);
702         sr32(CM_CAM_CLKSTCTRL, 0, 32, 0x0);
703
704         /* Enable DSS clocks */
705         /* PM_DSS_PWRSTCTRL ON State and LogicState = 1 (Retention) */
706         __raw_writel(7, 0x4A307100); /* DSS_PRM */
707
708         sr32(CM_DSS_CLKSTCTRL, 0, 32, 0x2);
709         sr32(CM_DSS_DSS_CLKCTRL, 0, 32, 0xf02);
710         sr32(CM_DSS_DEISS_CLKCTRL, 0, 32, 0x2);
711
712         /* Check for DSS Clocks */
713         while ((__raw_readl(0x4A009100) & 0xF00) != 0xE00)
714                 ;
715         /* Set HW_AUTO transition mode */
716         sr32(CM_DSS_CLKSTCTRL, 0, 32, 0x3);
717
718         /* Enable SGX clocks */
719         sr32(CM_SGX_CLKSTCTRL, 0, 32, 0x2);
720         sr32(CM_SGX_SGX_CLKCTRL, 0, 32, 0x2);
721         /* Check for SGX FCLK and ICLK */
722         while (__raw_readl(0x4A009200) != 0x302)
723                 ;
724         /* Enable hsi/unipro/usb clocks */
725         sr32(CM_L3INIT_HSI_CLKCTRL, 0, 32, 0x1);
726         sr32(CM_L3INIT_UNIPRO1_CLKCTRL, 0, 32, 0x2);
727         sr32(CM_L3INIT_HSUSBHOST_CLKCTRL, 0, 32, 0x2);
728         sr32(CM_L3INIT_HSUSBOTG_CLKCTRL, 0, 32, 0x1);
729         sr32(CM_L3INIT_HSUSBTLL_CLKCTRL, 0, 32, 0x1);
730         sr32(CM_L3INIT_FSUSB_CLKCTRL, 0, 32, 0x2);
731         /* enable the 32K, 48M optional clocks and enable the module */
732         sr32(CM_L3INIT_USBPHY_CLKCTRL, 0, 32, 0x301);
733 }
734
735 /******************************************************************************
736  * prcm_init() - inits clocks for PRCM as defined in clocks.h
737  *   -- called from SRAM, or Flash (using temp SRAM stack).
738  *****************************************************************************/
739 void prcm_init(void)
740 {
741         u32 clk_index;
742
743         /* Get the sysclk speed from cm_sys_clksel
744          * Set the CM_SYS_CLKSEL in case ROM code has not set
745          */
746         __raw_writel(0x7, CM_SYS_CLKSEL);
747         clk_index = readl(CM_SYS_CLKSEL);
748         if (!clk_index)
749                 return; /* Sys clk uninitialized */
750         /* Core DPLL is locked using FREQ update method */
751         /* configure_core_dpll(clk_index - 1); */
752
753         /* Configure all DPLL's at 100% OPP */
754         configure_mpu_dpll(clk_index - 1);
755         configure_iva_dpll(clk_index - 1);
756         configure_per_dpll(clk_index - 1);
757         configure_abe_dpll(clk_index - 1);
758         configure_usb_dpll(clk_index - 1);
759
760 #ifdef CONFIG_OMAP4_SDC
761         /* Enable all clocks */
762         enable_all_clocks();
763 #endif
764 }