xloader: Panda - convert explicit volatile rw to __raw_xx
[x-loader:mio-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         /* Wait for Freq_Update to get cleared: CM_SHADOW_FREQ_CONFIG1 */
540         while (__raw_readl(0x4A004260) & 1)
541                 ;
542
543         /* Wait for DPLL to Lock : CM_IDLEST_DPLL_CORE */
544         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_CORE, LDELAY);
545         /* lock_core_dpll(); */
546 }
547
548 static void enable_all_clocks(void)
549 {
550         /* Enable Ducati clocks */
551         sr32(CM_DUCATI_DUCATI_CLKCTRL, 0, 32, 0x1);
552         sr32(CM_DUCATI_CLKSTCTRL, 0, 32, 0x2);
553
554         wait_on_value(BIT8, BIT8, CM_DUCATI_CLKSTCTRL, LDELAY);
555         /*
556          * wait_on_value(BIT18|BIT17|BIT16, 0, CM_DUCATI_DUCATI_CLKCTRL,
557          *      LDELAY);
558          */
559
560         /* Enable ivahd and sl2 clocks */
561         sr32(IVAHD_IVAHD_CLKCTRL, 0, 32, 0x1);
562         sr32(IVAHD_SL2_CLKCTRL, 0, 32, 0x1);
563         sr32(IVAHD_CLKSTCTRL, 0, 32, 0x2);
564
565         wait_on_value(BIT8, BIT8, IVAHD_CLKSTCTRL, LDELAY);
566
567         /* wait for ivahd to become accessible */
568         /* wait_on_value(BIT18|BIT17|BIT16, 0, IVAHD_IVAHD_CLKCTRL, LDELAY); */
569         /* wait for sl2 to become accessible */
570         /* wait_on_value(BIT17|BIT16, 0, IVAHD_SL2_CLKCTRL, LDELAY); */
571
572         /* Enable Tesla clocks */
573         sr32(DSP_DSP_CLKCTRL, 0, 32, 0x1);
574         sr32(DSP_CLKSTCTRL, 0, 32, 0x2);
575
576         wait_on_value(BIT8, BIT8, DSP_CLKSTCTRL, LDELAY);
577
578         /* wait for tesla to become accessible */
579         /* wait_on_value(BIT18|BIT17|BIT16, 0, DSP_DSP_CLKCTRL, LDELAY); */
580
581         /* TODO: Some hack needed by MM: Clean this */
582         #if 0 /* Doesn't work on some Zebu */
583         *(volatile int *)0x4a306910 = 0x00000003;
584         *(volatile int *)0x550809a0 = 0x00000001;
585         *(volatile int *)0x55080a20 = 0x00000007;
586         #endif
587
588         /* ABE clocks */
589         sr32(CM1_ABE_CLKSTCTRL, 0, 32, 0x3);
590         sr32(CM1_ABE_AESS_CLKCTRL, 0, 32, 0x2);
591         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM1_ABE_AESS_CLKCTRL, LDELAY); */
592         sr32(CM1_ABE_PDM_CLKCTRL, 0, 32, 0x2);
593         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_PDM_CLKCTRL, LDELAY); */
594         sr32(CM1_ABE_DMIC_CLKCTRL, 0, 32, 0x2);
595         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_DMIC_CLKCTRL, LDELAY); */
596         sr32(CM1_ABE_MCASP_CLKCTRL, 0, 32, 0x2);
597         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCASP_CLKCTRL, LDELAY); */
598         sr32(CM1_ABE_MCBSP1_CLKCTRL, 0, 32, 0x08000002);
599         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCBSP1_CLKCTRL, LDELAY); */
600         sr32(CM1_ABE_MCBSP2_CLKCTRL, 0, 32, 0x08000002);
601         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCBSP2_CLKCTRL, LDELAY); */
602         sr32(CM1_ABE_MCBSP3_CLKCTRL, 0, 32, 0x08000002);
603         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCBSP3_CLKCTRL, LDELAY); */
604         sr32(CM1_ABE_SLIMBUS_CLKCTRL, 0, 32, 0xf02);
605         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_SLIMBUS_CLKCTRL, LDELAY); */
606         sr32(CM1_ABE_TIMER5_CLKCTRL, 0, 32, 0x2);
607         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER5_CLKCTRL, LDELAY); */
608         sr32(CM1_ABE_TIMER6_CLKCTRL, 0, 32, 0x2);
609         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER6_CLKCTRL, LDELAY); */
610         sr32(CM1_ABE_TIMER7_CLKCTRL, 0, 32, 0x2);
611         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER7_CLKCTRL, LDELAY); */
612         sr32(CM1_ABE_TIMER8_CLKCTRL, 0, 32, 0x2);
613         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER8_CLKCTRL, LDELAY); */
614         sr32(CM1_ABE_WDT3_CLKCTRL, 0, 32, 0x2);
615         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_WDT3_CLKCTRL, LDELAY); */
616         /* Disable sleep transitions */
617         sr32(CM1_ABE_CLKSTCTRL, 0, 32, 0x0);
618
619         /* L4PER clocks */
620         sr32(CM_L4PER_CLKSTCTRL, 0, 32, 0x2);
621         sr32(CM_L4PER_DMTIMER10_CLKCTRL, 0, 32, 0x2);
622         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER10_CLKCTRL, LDELAY);
623         sr32(CM_L4PER_DMTIMER11_CLKCTRL, 0, 32, 0x2);
624         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER11_CLKCTRL, LDELAY);
625         sr32(CM_L4PER_DMTIMER2_CLKCTRL, 0, 32, 0x2);
626         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER2_CLKCTRL, LDELAY);
627         sr32(CM_L4PER_DMTIMER3_CLKCTRL, 0, 32, 0x2);
628         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER3_CLKCTRL, LDELAY);
629         sr32(CM_L4PER_DMTIMER4_CLKCTRL, 0, 32, 0x2);
630         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER4_CLKCTRL, LDELAY);
631         sr32(CM_L4PER_DMTIMER9_CLKCTRL, 0, 32, 0x2);
632         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER9_CLKCTRL, LDELAY);
633
634         /* GPIO clocks */
635         sr32(CM_L4PER_GPIO2_CLKCTRL, 0, 32, 0x1);
636         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO2_CLKCTRL, LDELAY);
637         sr32(CM_L4PER_GPIO3_CLKCTRL, 0, 32, 0x1);
638         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO3_CLKCTRL, LDELAY);
639         sr32(CM_L4PER_GPIO4_CLKCTRL, 0, 32, 0x1);
640         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO4_CLKCTRL, LDELAY);
641         sr32(CM_L4PER_GPIO5_CLKCTRL, 0, 32, 0x1);
642         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO5_CLKCTRL, LDELAY);
643         sr32(CM_L4PER_GPIO6_CLKCTRL, 0, 32, 0x1);
644         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO6_CLKCTRL, LDELAY);
645
646         sr32(CM_L4PER_HDQ1W_CLKCTRL, 0, 32, 0x2);
647
648         /* I2C clocks */
649         sr32(CM_L4PER_I2C1_CLKCTRL, 0, 32, 0x2);
650         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C1_CLKCTRL, LDELAY);
651         sr32(CM_L4PER_I2C2_CLKCTRL, 0, 32, 0x2);
652         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C2_CLKCTRL, LDELAY);
653         sr32(CM_L4PER_I2C3_CLKCTRL, 0, 32, 0x2);
654         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C3_CLKCTRL, LDELAY);
655         sr32(CM_L4PER_I2C4_CLKCTRL, 0, 32, 0x2);
656         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C4_CLKCTRL, LDELAY);
657
658         sr32(CM_L4PER_MCBSP4_CLKCTRL, 0, 32, 0x2);
659         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCBSP4_CLKCTRL, LDELAY);
660
661         /* MCSPI clocks */
662         sr32(CM_L4PER_MCSPI1_CLKCTRL, 0, 32, 0x2);
663         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI1_CLKCTRL, LDELAY);
664         sr32(CM_L4PER_MCSPI2_CLKCTRL, 0, 32, 0x2);
665         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI2_CLKCTRL, LDELAY);
666         sr32(CM_L4PER_MCSPI3_CLKCTRL, 0, 32, 0x2);
667         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI3_CLKCTRL, LDELAY);
668         sr32(CM_L4PER_MCSPI4_CLKCTRL, 0, 32, 0x2);
669         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI4_CLKCTRL, LDELAY);
670
671         /* MMC clocks */
672         sr32(CM_L3INIT_HSMMC1_CLKCTRL, 0, 2, 0x2);
673         sr32(CM_L3INIT_HSMMC1_CLKCTRL, 24, 1, 0x1);
674         /*wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSMMC1_CLKCTRL,
675          *      LDELAY); */
676         sr32(CM_L3INIT_HSMMC2_CLKCTRL, 0, 2, 0x2);
677         sr32(CM_L3INIT_HSMMC2_CLKCTRL, 24, 1, 0x1);
678         /*wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSMMC2_CLKCTRL,
679          *      LDELAY); */
680         sr32(CM_L4PER_MMCSD3_CLKCTRL, 0, 32, 0x2);
681         wait_on_value(BIT18|BIT17|BIT16, 0, CM_L4PER_MMCSD3_CLKCTRL, LDELAY);
682         sr32(CM_L4PER_MMCSD4_CLKCTRL, 0, 32, 0x2);
683         wait_on_value(BIT18|BIT17|BIT16, 0, CM_L4PER_MMCSD4_CLKCTRL, LDELAY);
684         sr32(CM_L4PER_MMCSD5_CLKCTRL, 0, 32, 0x2);
685         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MMCSD5_CLKCTRL, LDELAY);
686
687         /* UART clocks */
688         sr32(CM_L4PER_UART1_CLKCTRL, 0, 32, 0x2);
689         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART1_CLKCTRL, LDELAY);
690         sr32(CM_L4PER_UART2_CLKCTRL, 0, 32, 0x2);
691         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART2_CLKCTRL, LDELAY);
692         sr32(CM_L4PER_UART3_CLKCTRL, 0, 32, 0x2);
693         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART3_CLKCTRL, LDELAY);
694         sr32(CM_L4PER_UART4_CLKCTRL, 0, 32, 0x2);
695         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART4_CLKCTRL, LDELAY);
696
697         /* WKUP clocks */
698         sr32(CM_WKUP_GPIO1_CLKCTRL, 0, 32, 0x1);
699         wait_on_value(BIT17|BIT16, 0, CM_WKUP_GPIO1_CLKCTRL, LDELAY);
700         sr32(CM_WKUP_TIMER1_CLKCTRL, 0, 32, 0x01000002);
701         wait_on_value(BIT17|BIT16, 0, CM_WKUP_TIMER1_CLKCTRL, LDELAY);
702
703         sr32(CM_WKUP_KEYBOARD_CLKCTRL, 0, 32, 0x2);
704         wait_on_value(BIT17|BIT16, 0, CM_WKUP_KEYBOARD_CLKCTRL, LDELAY);
705
706         sr32(CM_SDMA_CLKSTCTRL, 0, 32, 0x0);
707         sr32(CM_MEMIF_CLKSTCTRL, 0, 32, 0x3);
708         sr32(CM_MEMIF_EMIF_1_CLKCTRL, 0, 32, 0x1);
709         wait_on_value(BIT17|BIT16, 0, CM_MEMIF_EMIF_1_CLKCTRL, LDELAY);
710         sr32(CM_MEMIF_EMIF_2_CLKCTRL, 0, 32, 0x1);
711         wait_on_value(BIT17|BIT16, 0, CM_MEMIF_EMIF_2_CLKCTRL, LDELAY);
712         sr32(CM_D2D_CLKSTCTRL, 0, 32, 0x3);
713         sr32(CM_L3_2_GPMC_CLKCTRL, 0, 32, 0x1);
714         wait_on_value(BIT17|BIT16, 0, CM_L3_2_GPMC_CLKCTRL, LDELAY);
715         sr32(CM_L3INSTR_L3_3_CLKCTRL, 0, 32, 0x1);
716         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_L3_3_CLKCTRL, LDELAY);
717         sr32(CM_L3INSTR_L3_INSTR_CLKCTRL, 0, 32, 0x1);
718         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_L3_INSTR_CLKCTRL, LDELAY);
719         sr32(CM_L3INSTR_OCP_WP1_CLKCTRL, 0, 32, 0x1);
720         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_OCP_WP1_CLKCTRL, LDELAY);
721
722         /* WDT clocks */
723         sr32(CM_WKUP_WDT2_CLKCTRL, 0, 32, 0x2);
724         wait_on_value(BIT17|BIT16, 0, CM_WKUP_WDT2_CLKCTRL, LDELAY);
725
726         /* Enable Camera clocks */
727         sr32(CM_CAM_CLKSTCTRL, 0, 32, 0x3);
728         sr32(CM_CAM_ISS_CLKCTRL, 0, 32, 0x102);
729         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_CAM_ISS_CLKCTRL, LDELAY); */
730         sr32(CM_CAM_FDIF_CLKCTRL, 0, 32, 0x2);
731         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_CAM_FDIF_CLKCTRL, LDELAY); */
732         sr32(CM_CAM_CLKSTCTRL, 0, 32, 0x0);
733
734         /* Enable DSS clocks */
735         /* PM_DSS_PWRSTCTRL ON State and LogicState = 1 (Retention) */
736         __raw_writel(7, 0x4A307100); /* DSS_PRM */
737
738         sr32(CM_DSS_CLKSTCTRL, 0, 32, 0x2);
739         sr32(CM_DSS_DSS_CLKCTRL, 0, 32, 0xf02);
740         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_DSS_DSS_CLKCTRL, LDELAY); */
741         sr32(CM_DSS_DEISS_CLKCTRL, 0, 32, 0x2);
742         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_DSS_DEISS_CLKCTRL, LDELAY); */
743
744         /* Check for DSS Clocks */
745         while ((__raw_readl(0x4A009100) & 0xF00) != 0xE00)
746                 ;
747         /* Set HW_AUTO transition mode */
748         sr32(CM_DSS_CLKSTCTRL, 0, 32, 0x3);
749
750         /* Enable SGX clocks */
751         sr32(CM_SGX_CLKSTCTRL, 0, 32, 0x2);
752         sr32(CM_SGX_SGX_CLKCTRL, 0, 32, 0x2);
753         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_SGX_SGX_CLKCTRL, LDELAY); */
754         /* Check for SGX FCLK and ICLK */
755         while (__raw_readl(0x4A009200) != 0x302)
756                 ;
757         /* sr32(CM_SGX_CLKSTCTRL, 0, 32, 0x0); */
758         /* Enable hsi/unipro/usb clocks */
759         sr32(CM_L3INIT_HSI_CLKCTRL, 0, 32, 0x1);
760         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSI_CLKCTRL,
761          *      LDELAY); */
762         sr32(CM_L3INIT_UNIPRO1_CLKCTRL, 0, 32, 0x2);
763         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_UNIPRO1_CLKCTRL,
764          *      LDELAY); */
765         sr32(CM_L3INIT_HSUSBHOST_CLKCTRL, 0, 32, 0x2);
766         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSUSBHOST_CLKCTRL,
767          *      LDELAY); */
768         sr32(CM_L3INIT_HSUSBOTG_CLKCTRL, 0, 32, 0x1);
769         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSUSBOTG_CLKCTRL,
770          *      LDELAY); */
771         sr32(CM_L3INIT_HSUSBTLL_CLKCTRL, 0, 32, 0x1);
772         /* wait_on_value(BIT17|BIT16, 0, CM_L3INIT_HSUSBTLL_CLKCTRL, LDELAY); */
773         sr32(CM_L3INIT_FSUSB_CLKCTRL, 0, 32, 0x2);
774         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_FSUSB_CLKCTRL,
775          *      LDELAY); */
776         /* enable the 32K, 48M optional clocks and enable the module */
777         sr32(CM_L3INIT_USBPHY_CLKCTRL, 0, 32, 0x301);
778         /* wait_on_value(BIT17|BIT16, 0, CM_L3INIT_USBPHY_CLKCTRL, LDELAY); */
779 }
780
781 /******************************************************************************
782  * prcm_init() - inits clocks for PRCM as defined in clocks.h
783  *   -- called from SRAM, or Flash (using temp SRAM stack).
784  *****************************************************************************/
785 void prcm_init(void)
786 {
787         u32 clk_index;
788
789         /* Get the sysclk speed from cm_sys_clksel
790          * Set the CM_SYS_CLKSEL in case ROM code has not set
791          */
792         __raw_writel(0x7, CM_SYS_CLKSEL);
793         clk_index = readl(CM_SYS_CLKSEL);
794         if (!clk_index)
795                 return; /* Sys clk uninitialized */
796         /* Core DPLL is locked using FREQ update method */
797         /* configure_core_dpll(clk_index - 1); */
798
799         /* Configure all DPLL's at 100% OPP */
800         configure_mpu_dpll(clk_index - 1);
801         configure_iva_dpll(clk_index - 1);
802         configure_per_dpll(clk_index - 1);
803         configure_abe_dpll(clk_index - 1);
804         configure_usb_dpll(clk_index - 1);
805
806 #ifdef CONFIG_OMAP4_SDC
807         /* Enable all clocks */
808         enable_all_clocks();
809 #endif
810 }