xloader: Panda - clean board files style
[x-loader:tajourias-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         return;
253 }
254
255 static void configure_iva_dpll(u32 clk_index)
256 {
257         struct dpll_param *dpll_param_p;
258
259         /* Unlock the IVA dpll */
260         sr32(CM_CLKMODE_DPLL_IVA, 0, 3, PLL_MN_POWER_BYPASS);
261         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_IVA, LDELAY);
262
263         /* CM_BYPCLK_DPLL_IVA = CORE_X2_CLK/2 */
264         sr32(CM_BYPCLK_DPLL_IVA, 0, 2, 0x1);
265
266         /* Program IVA DPLL */
267         dpll_param_p = &iva_dpll_param[clk_index];
268
269         sr32(CM_AUTOIDLE_DPLL_IVA, 0, 3, 0x0); /* Disable DPLL autoidle */
270
271         /* Set M,N,M4,M5 */
272         sr32(CM_CLKSEL_DPLL_IVA, 8, 11, dpll_param_p->m);
273         sr32(CM_CLKSEL_DPLL_IVA, 0, 7, dpll_param_p->n);
274         sr32(CM_DIV_M4_DPLL_IVA, 0, 5, dpll_param_p->m4);
275         sr32(CM_DIV_M4_DPLL_IVA, 8, 1, 0x1);
276         sr32(CM_DIV_M5_DPLL_IVA, 0, 5, dpll_param_p->m5);
277         sr32(CM_DIV_M5_DPLL_IVA, 8, 1, 0x1);
278
279         /* Lock the iva dpll */
280         sr32(CM_CLKMODE_DPLL_IVA, 0, 3, PLL_LOCK);
281         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_IVA, LDELAY);
282 }
283
284 static void configure_per_dpll(u32 clk_index)
285 {
286         struct dpll_param *dpll_param_p;
287
288         /* Unlock the PER dpll */
289         sr32(CM_CLKMODE_DPLL_PER, 0, 3, PLL_MN_POWER_BYPASS);
290         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_PER, LDELAY);
291
292         /* Program PER DPLL */
293         dpll_param_p = &per_dpll_param[clk_index];
294
295         /* Disable autoidle */
296         sr32(CM_AUTOIDLE_DPLL_PER, 0, 3, 0x0);
297
298         sr32(CM_CLKSEL_DPLL_PER, 8, 11, dpll_param_p->m);
299         sr32(CM_CLKSEL_DPLL_PER, 0, 6, dpll_param_p->n);
300         sr32(CM_DIV_M2_DPLL_PER, 0, 5, dpll_param_p->m2);
301         sr32(CM_DIV_M3_DPLL_PER, 0, 5, dpll_param_p->m3);
302         sr32(CM_DIV_M4_DPLL_PER, 0, 5, dpll_param_p->m4);
303         sr32(CM_DIV_M5_DPLL_PER, 0, 5, dpll_param_p->m5);
304         sr32(CM_DIV_M6_DPLL_PER, 0, 5, dpll_param_p->m6);
305         sr32(CM_DIV_M7_DPLL_PER, 0, 5, dpll_param_p->m7);
306
307
308         sr32(CM_DIV_M2_DPLL_PER, 8, 1, 0x1);
309         sr32(CM_DIV_M3_DPLL_PER, 8, 1, 0x1);
310         sr32(CM_DIV_M4_DPLL_PER, 8, 1, 0x1);
311         sr32(CM_DIV_M5_DPLL_PER, 8, 1, 0x1);
312         sr32(CM_DIV_M6_DPLL_PER, 8, 1, 0x1);
313         sr32(CM_DIV_M7_DPLL_PER, 8, 1, 0x1);
314
315         /* Lock the per dpll */
316         sr32(CM_CLKMODE_DPLL_PER, 0, 3, PLL_LOCK);
317         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_PER, LDELAY);
318 }
319
320 static void configure_abe_dpll(u32 clk_index)
321 {
322         struct dpll_param *dpll_param_p;
323
324         /* Select sys_clk as ref clk for ABE dpll */
325         sr32(CM_ABE_PLL_REF_CLKSEL, 0, 32, 0x0);
326
327         /* Enable slimbus and pad clocks */
328         sr32(CM_CLKSEL_ABE, 0, 32, 0x500);
329
330         /* Unlock the ABE dpll */
331         sr32(CM_CLKMODE_DPLL_ABE, 0, 3, PLL_MN_POWER_BYPASS);
332         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_ABE, LDELAY);
333
334         /* Program ABE DPLL */
335         dpll_param_p = &abe_dpll_param[clk_index];
336
337         /* Disable autoidle */
338         sr32(CM_AUTOIDLE_DPLL_ABE, 0, 3, 0x0);
339
340         sr32(CM_CLKSEL_DPLL_ABE, 8, 11, dpll_param_p->m);
341         sr32(CM_CLKSEL_DPLL_ABE, 0, 6, dpll_param_p->n);
342
343         /* Force DPLL CLKOUTHIF to stay enabled */
344         sr32(CM_DIV_M2_DPLL_ABE, 0, 32, 0x500);
345         sr32(CM_DIV_M2_DPLL_ABE, 0, 5, dpll_param_p->m2);
346         sr32(CM_DIV_M2_DPLL_ABE, 8, 1, 0x1);
347         /* Force DPLL CLKOUTHIF to stay enabled */
348         sr32(CM_DIV_M3_DPLL_ABE, 0, 32, 0x100);
349         sr32(CM_DIV_M3_DPLL_ABE, 0, 5, dpll_param_p->m3);
350         sr32(CM_DIV_M3_DPLL_ABE, 8, 1, 0x1);
351
352         /* Lock the abe dpll */
353         sr32(CM_CLKMODE_DPLL_ABE, 0, 3, PLL_LOCK);
354         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_ABE, LDELAY);
355 }
356
357 static void configure_usb_dpll(u32 clk_index)
358 {
359         struct dpll_param *dpll_param_p;
360
361         /* Select the 60Mhz clock 480/8 = 60*/
362         sr32(CM_CLKSEL_USB_60MHz, 0, 32, 0x1);
363
364         /* Unlock the USB dpll */
365         sr32(CM_CLKMODE_DPLL_USB, 0, 3, PLL_MN_POWER_BYPASS);
366         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_USB, LDELAY);
367
368         /* Program USB DPLL */
369         dpll_param_p = &usb_dpll_param[clk_index];
370
371         /* Disable autoidle */
372         sr32(CM_AUTOIDLE_DPLL_USB, 0, 3, 0x0);
373
374         sr32(CM_CLKSEL_DPLL_USB, 8, 11, dpll_param_p->m);
375         sr32(CM_CLKSEL_DPLL_USB, 0, 6, dpll_param_p->n);
376
377         /* Force DPLL CLKOUT to stay active */
378         sr32(CM_DIV_M2_DPLL_USB, 0, 32, 0x100);
379         sr32(CM_DIV_M2_DPLL_USB, 0, 5, dpll_param_p->m2);
380         sr32(CM_DIV_M2_DPLL_USB, 8, 1, 0x1);
381         sr32(CM_CLKDCOLDO_DPLL_USB, 8, 1, 0x1);
382
383         /* Lock the usb dpll */
384         sr32(CM_CLKMODE_DPLL_USB, 0, 3, PLL_LOCK);
385         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_USB, LDELAY);
386
387         /* force enable the CLKDCOLDO clock */
388         sr32(CM_CLKDCOLDO_DPLL_USB, 0, 32, 0x100);
389 }
390
391 static void configure_core_dpll(clk_index)
392 {
393         struct dpll_param *dpll_param_p;
394
395         /* Get the sysclk speed from cm_sys_clksel
396          * Set it to 38.4 MHz, in case ROM code is bypassed
397          */
398         if (!clk_index)
399                 return;
400
401         /* CORE_CLK=CORE_X2_CLK/2, L3_CLK=CORE_CLK/2, L4_CLK=L3_CLK/2 */
402         sr32(CM_CLKSEL_CORE, 0, 32, 0x110);
403
404         /* Unlock the CORE dpll */
405         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_MN_POWER_BYPASS);
406         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_CORE, LDELAY);
407
408         /* Program Core DPLL */
409         switch (omap_revision()) {
410         case OMAP4430_ES1_0:
411                 dpll_param_p = &core_dpll_param_l3_190[clk_index];
412                 break;
413         case OMAP4430_ES2_0:
414                 dpll_param_p = &core_dpll_param[clk_index];
415                 break;
416         case OMAP4430_ES2_1:
417                 dpll_param_p = &core_dpll_param_ddr400[clk_index];
418                 break;
419         }
420
421         /* Disable autoidle */
422         sr32(CM_AUTOIDLE_DPLL_CORE, 0, 3, 0x0);
423
424         sr32(CM_CLKSEL_DPLL_CORE, 8, 11, dpll_param_p->m);
425         sr32(CM_CLKSEL_DPLL_CORE, 0, 6, dpll_param_p->n);
426         sr32(CM_DIV_M2_DPLL_CORE, 0, 5, dpll_param_p->m2);
427         sr32(CM_DIV_M3_DPLL_CORE, 0, 5, dpll_param_p->m3);
428         sr32(CM_DIV_M4_DPLL_CORE, 0, 5, dpll_param_p->m4);
429         sr32(CM_DIV_M5_DPLL_CORE, 0, 5, dpll_param_p->m5);
430         sr32(CM_DIV_M6_DPLL_CORE, 0, 5, dpll_param_p->m6);
431         sr32(CM_DIV_M7_DPLL_CORE, 0, 5, dpll_param_p->m7);
432
433         if (omap_revision() == OMAP4430_ES1_0) {
434                 /* Do this only on ES1.0 */
435                 sr32(CM_DIV_M2_DPLL_CORE, 8, 1, 0x1);
436                 sr32(CM_DIV_M3_DPLL_CORE, 8, 1, 0x1);
437                 sr32(CM_DIV_M4_DPLL_CORE, 8, 1, 0x1);
438                 sr32(CM_DIV_M5_DPLL_CORE, 8, 1, 0x1);
439                 sr32(CM_DIV_M6_DPLL_CORE, 8, 1, 0x0);
440                 sr32(CM_DIV_M7_DPLL_CORE, 8, 1, 0x1);
441         }
442
443         /* Lock the core dpll */
444         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_LOCK);
445         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_CORE, LDELAY);
446 }
447
448
449 void configure_core_dpll_no_lock(void)
450 {
451         struct dpll_param *dpll_param_p;
452         u32 clk_index;
453
454         /* Get the sysclk speed from cm_sys_clksel
455          * Set it to 38.4 MHz, in case ROM code is bypassed
456          */
457         __raw_writel(0x7, CM_SYS_CLKSEL);
458         clk_index = 7;
459
460         clk_index = clk_index - 1;
461         /* CORE_CLK=CORE_X2_CLK/2, L3_CLK=CORE_CLK/2, L4_CLK=L3_CLK/2 */
462         sr32(CM_CLKSEL_CORE, 0, 32, 0x110);
463
464         /* Unlock the CORE dpll */
465         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_MN_POWER_BYPASS);
466         wait_on_value(BIT0, 0, CM_IDLEST_DPLL_CORE, LDELAY);
467
468         /* Program Core DPLL */
469         switch (omap_revision()) {
470         case OMAP4430_ES1_0:
471                 dpll_param_p = &core_dpll_param_l3_190[clk_index];
472                 break;
473         case OMAP4430_ES2_0:
474                 dpll_param_p = &core_dpll_param[clk_index];
475                 break;
476         case OMAP4430_ES2_1:
477                 dpll_param_p = &core_dpll_param_ddr400[clk_index];
478                 break;
479         }
480
481         /* Disable autoidle */
482         sr32(CM_AUTOIDLE_DPLL_CORE, 0, 3, 0x0);
483
484         sr32(CM_CLKSEL_DPLL_CORE, 8, 11, dpll_param_p->m);
485         sr32(CM_CLKSEL_DPLL_CORE, 0, 6, dpll_param_p->n);
486         sr32(CM_DIV_M2_DPLL_CORE, 0, 5, dpll_param_p->m2);
487         sr32(CM_DIV_M3_DPLL_CORE, 0, 5, dpll_param_p->m3);
488         sr32(CM_DIV_M4_DPLL_CORE, 0, 5, dpll_param_p->m4);
489         sr32(CM_DIV_M5_DPLL_CORE, 0, 5, dpll_param_p->m5);
490         sr32(CM_DIV_M6_DPLL_CORE, 0, 5, dpll_param_p->m6);
491         sr32(CM_DIV_M7_DPLL_CORE, 0, 5, dpll_param_p->m7);
492
493         sr32(CM_DIV_M2_DPLL_CORE, 8, 1, 0x1);
494         sr32(CM_DIV_M3_DPLL_CORE, 8, 1, 0x1);
495         sr32(CM_DIV_M4_DPLL_CORE, 8, 1, 0x1);
496         sr32(CM_DIV_M5_DPLL_CORE, 8, 1, 0x1);
497         sr32(CM_DIV_M6_DPLL_CORE, 8, 1, 0x0);
498         sr32(CM_DIV_M7_DPLL_CORE, 8, 1, 0x1);
499 }
500
501 void lock_core_dpll(void)
502 {
503         /* Lock the core dpll */
504         sr32(CM_CLKMODE_DPLL_CORE, 0, 3, PLL_LOCK);
505         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_CORE, LDELAY);
506 }
507
508 void lock_core_dpll_shadow(void)
509 {
510         struct dpll_param *dpll_param_p;
511
512         /* Lock the core dpll using freq update method */
513         *(volatile int*)0x4A004120 = 10;        /* CM_CLKMODE_DPLL_CORE */
514
515         switch (omap_revision()) {
516         case OMAP4430_ES1_0:
517                 dpll_param_p = &core_dpll_param_l3_190[6];
518                 break;
519         case OMAP4430_ES2_0:
520                 dpll_param_p = &core_dpll_param[6];
521                 break;
522         case OMAP4430_ES2_1:
523                 dpll_param_p = &core_dpll_param_ddr400[6];
524                 break;
525         }
526
527         /* CM_SHADOW_FREQ_CONFIG1: DLL_OVERRIDE = 1(hack), DLL_RESET = 1,
528          * DPLL_CORE_M2_DIV =1, DPLL_CORE_DPLL_EN = 0x7, FREQ_UPDATE = 1
529          */
530         *(volatile int*)0x4A004260 = 0x70D | (dpll_param_p->m2 << 11);
531
532         /* Wait for Freq_Update to get cleared: CM_SHADOW_FREQ_CONFIG1 */
533         while (((*(volatile int*)0x4A004260) & 0x1) == 0x1)
534                 ;
535
536         /* Wait for DPLL to Lock : CM_IDLEST_DPLL_CORE */
537         wait_on_value(BIT0, 1, CM_IDLEST_DPLL_CORE, LDELAY);
538         /* lock_core_dpll(); */
539 }
540
541 static void enable_all_clocks(void)
542 {
543         volatile int regvalue = 0;
544
545         /* Enable Ducati clocks */
546         sr32(CM_DUCATI_DUCATI_CLKCTRL, 0, 32, 0x1);
547         sr32(CM_DUCATI_CLKSTCTRL, 0, 32, 0x2);
548
549         wait_on_value(BIT8, BIT8, CM_DUCATI_CLKSTCTRL, LDELAY);
550         /*
551          * wait_on_value(BIT18|BIT17|BIT16, 0, CM_DUCATI_DUCATI_CLKCTRL,
552          *      LDELAY);
553          */
554
555         /* Enable ivahd and sl2 clocks */
556         sr32(IVAHD_IVAHD_CLKCTRL, 0, 32, 0x1);
557         sr32(IVAHD_SL2_CLKCTRL, 0, 32, 0x1);
558         sr32(IVAHD_CLKSTCTRL, 0, 32, 0x2);
559
560         wait_on_value(BIT8, BIT8, IVAHD_CLKSTCTRL, LDELAY);
561
562         /* wait for ivahd to become accessible */
563         /* wait_on_value(BIT18|BIT17|BIT16, 0, IVAHD_IVAHD_CLKCTRL, LDELAY); */
564         /* wait for sl2 to become accessible */
565         /* wait_on_value(BIT17|BIT16, 0, IVAHD_SL2_CLKCTRL, LDELAY); */
566
567         /* Enable Tesla clocks */
568         sr32(DSP_DSP_CLKCTRL, 0, 32, 0x1);
569         sr32(DSP_CLKSTCTRL, 0, 32, 0x2);
570
571         wait_on_value(BIT8, BIT8, DSP_CLKSTCTRL, LDELAY);
572
573         /* wait for tesla to become accessible */
574         /* wait_on_value(BIT18|BIT17|BIT16, 0, DSP_DSP_CLKCTRL, LDELAY); */
575
576         /* TODO: Some hack needed by MM: Clean this */
577         #if 0 /* Doesn't work on some Zebu */
578         *(volatile int *)0x4a306910 = 0x00000003;
579         *(volatile int *)0x550809a0 = 0x00000001;
580         *(volatile int *)0x55080a20 = 0x00000007;
581         #endif
582
583         /* ABE clocks */
584         sr32(CM1_ABE_CLKSTCTRL, 0, 32, 0x3);
585         sr32(CM1_ABE_AESS_CLKCTRL, 0, 32, 0x2);
586         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM1_ABE_AESS_CLKCTRL, LDELAY); */
587         sr32(CM1_ABE_PDM_CLKCTRL, 0, 32, 0x2);
588         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_PDM_CLKCTRL, LDELAY); */
589         sr32(CM1_ABE_DMIC_CLKCTRL, 0, 32, 0x2);
590         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_DMIC_CLKCTRL, LDELAY); */
591         sr32(CM1_ABE_MCASP_CLKCTRL, 0, 32, 0x2);
592         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCASP_CLKCTRL, LDELAY); */
593         sr32(CM1_ABE_MCBSP1_CLKCTRL, 0, 32, 0x08000002);
594         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCBSP1_CLKCTRL, LDELAY); */
595         sr32(CM1_ABE_MCBSP2_CLKCTRL, 0, 32, 0x08000002);
596         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCBSP2_CLKCTRL, LDELAY); */
597         sr32(CM1_ABE_MCBSP3_CLKCTRL, 0, 32, 0x08000002);
598         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_MCBSP3_CLKCTRL, LDELAY); */
599         sr32(CM1_ABE_SLIMBUS_CLKCTRL, 0, 32, 0xf02);
600         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_SLIMBUS_CLKCTRL, LDELAY); */
601         sr32(CM1_ABE_TIMER5_CLKCTRL, 0, 32, 0x2);
602         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER5_CLKCTRL, LDELAY); */
603         sr32(CM1_ABE_TIMER6_CLKCTRL, 0, 32, 0x2);
604         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER6_CLKCTRL, LDELAY); */
605         sr32(CM1_ABE_TIMER7_CLKCTRL, 0, 32, 0x2);
606         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER7_CLKCTRL, LDELAY); */
607         sr32(CM1_ABE_TIMER8_CLKCTRL, 0, 32, 0x2);
608         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_TIMER8_CLKCTRL, LDELAY); */
609         sr32(CM1_ABE_WDT3_CLKCTRL, 0, 32, 0x2);
610         /* wait_on_value(BIT17|BIT16, 0, CM1_ABE_WDT3_CLKCTRL, LDELAY); */
611         /* Disable sleep transitions */
612         sr32(CM1_ABE_CLKSTCTRL, 0, 32, 0x0);
613
614         /* L4PER clocks */
615         sr32(CM_L4PER_CLKSTCTRL, 0, 32, 0x2);
616         sr32(CM_L4PER_DMTIMER10_CLKCTRL, 0, 32, 0x2);
617         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER10_CLKCTRL, LDELAY);
618         sr32(CM_L4PER_DMTIMER11_CLKCTRL, 0, 32, 0x2);
619         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER11_CLKCTRL, LDELAY);
620         sr32(CM_L4PER_DMTIMER2_CLKCTRL, 0, 32, 0x2);
621         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER2_CLKCTRL, LDELAY);
622         sr32(CM_L4PER_DMTIMER3_CLKCTRL, 0, 32, 0x2);
623         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER3_CLKCTRL, LDELAY);
624         sr32(CM_L4PER_DMTIMER4_CLKCTRL, 0, 32, 0x2);
625         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER4_CLKCTRL, LDELAY);
626         sr32(CM_L4PER_DMTIMER9_CLKCTRL, 0, 32, 0x2);
627         wait_on_value(BIT17|BIT16, 0, CM_L4PER_DMTIMER9_CLKCTRL, LDELAY);
628
629         /* GPIO clocks */
630         sr32(CM_L4PER_GPIO2_CLKCTRL, 0, 32, 0x1);
631         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO2_CLKCTRL, LDELAY);
632         sr32(CM_L4PER_GPIO3_CLKCTRL, 0, 32, 0x1);
633         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO3_CLKCTRL, LDELAY);
634         sr32(CM_L4PER_GPIO4_CLKCTRL, 0, 32, 0x1);
635         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO4_CLKCTRL, LDELAY);
636         sr32(CM_L4PER_GPIO5_CLKCTRL, 0, 32, 0x1);
637         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO5_CLKCTRL, LDELAY);
638         sr32(CM_L4PER_GPIO6_CLKCTRL, 0, 32, 0x1);
639         wait_on_value(BIT17|BIT16, 0, CM_L4PER_GPIO6_CLKCTRL, LDELAY);
640
641         sr32(CM_L4PER_HDQ1W_CLKCTRL, 0, 32, 0x2);
642
643         /* I2C clocks */
644         sr32(CM_L4PER_I2C1_CLKCTRL, 0, 32, 0x2);
645         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C1_CLKCTRL, LDELAY);
646         sr32(CM_L4PER_I2C2_CLKCTRL, 0, 32, 0x2);
647         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C2_CLKCTRL, LDELAY);
648         sr32(CM_L4PER_I2C3_CLKCTRL, 0, 32, 0x2);
649         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C3_CLKCTRL, LDELAY);
650         sr32(CM_L4PER_I2C4_CLKCTRL, 0, 32, 0x2);
651         wait_on_value(BIT17|BIT16, 0, CM_L4PER_I2C4_CLKCTRL, LDELAY);
652
653         sr32(CM_L4PER_MCBSP4_CLKCTRL, 0, 32, 0x2);
654         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCBSP4_CLKCTRL, LDELAY);
655
656         /* MCSPI clocks */
657         sr32(CM_L4PER_MCSPI1_CLKCTRL, 0, 32, 0x2);
658         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI1_CLKCTRL, LDELAY);
659         sr32(CM_L4PER_MCSPI2_CLKCTRL, 0, 32, 0x2);
660         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI2_CLKCTRL, LDELAY);
661         sr32(CM_L4PER_MCSPI3_CLKCTRL, 0, 32, 0x2);
662         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI3_CLKCTRL, LDELAY);
663         sr32(CM_L4PER_MCSPI4_CLKCTRL, 0, 32, 0x2);
664         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MCSPI4_CLKCTRL, LDELAY);
665
666         /* MMC clocks */
667         sr32(CM_L3INIT_HSMMC1_CLKCTRL, 0, 2, 0x2);
668         sr32(CM_L3INIT_HSMMC1_CLKCTRL, 24, 1, 0x1);
669         /*wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSMMC1_CLKCTRL,
670          *      LDELAY); */
671         sr32(CM_L3INIT_HSMMC2_CLKCTRL, 0, 2, 0x2);
672         sr32(CM_L3INIT_HSMMC2_CLKCTRL, 24, 1, 0x1);
673         /*wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSMMC2_CLKCTRL,
674          *      LDELAY); */
675         sr32(CM_L4PER_MMCSD3_CLKCTRL, 0, 32, 0x2);
676         wait_on_value(BIT18|BIT17|BIT16, 0, CM_L4PER_MMCSD3_CLKCTRL, LDELAY);
677         sr32(CM_L4PER_MMCSD4_CLKCTRL, 0, 32, 0x2);
678         wait_on_value(BIT18|BIT17|BIT16, 0, CM_L4PER_MMCSD4_CLKCTRL, LDELAY);
679         sr32(CM_L4PER_MMCSD5_CLKCTRL, 0, 32, 0x2);
680         wait_on_value(BIT17|BIT16, 0, CM_L4PER_MMCSD5_CLKCTRL, LDELAY);
681
682         /* UART clocks */
683         sr32(CM_L4PER_UART1_CLKCTRL, 0, 32, 0x2);
684         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART1_CLKCTRL, LDELAY);
685         sr32(CM_L4PER_UART2_CLKCTRL, 0, 32, 0x2);
686         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART2_CLKCTRL, LDELAY);
687         sr32(CM_L4PER_UART3_CLKCTRL, 0, 32, 0x2);
688         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART3_CLKCTRL, LDELAY);
689         sr32(CM_L4PER_UART4_CLKCTRL, 0, 32, 0x2);
690         wait_on_value(BIT17|BIT16, 0, CM_L4PER_UART4_CLKCTRL, LDELAY);
691
692         /* WKUP clocks */
693         sr32(CM_WKUP_GPIO1_CLKCTRL, 0, 32, 0x1);
694         wait_on_value(BIT17|BIT16, 0, CM_WKUP_GPIO1_CLKCTRL, LDELAY);
695         sr32(CM_WKUP_TIMER1_CLKCTRL, 0, 32, 0x01000002);
696         wait_on_value(BIT17|BIT16, 0, CM_WKUP_TIMER1_CLKCTRL, LDELAY);
697
698         sr32(CM_WKUP_KEYBOARD_CLKCTRL, 0, 32, 0x2);
699         wait_on_value(BIT17|BIT16, 0, CM_WKUP_KEYBOARD_CLKCTRL, LDELAY);
700
701         sr32(CM_SDMA_CLKSTCTRL, 0, 32, 0x0);
702         sr32(CM_MEMIF_CLKSTCTRL, 0, 32, 0x3);
703         sr32(CM_MEMIF_EMIF_1_CLKCTRL, 0, 32, 0x1);
704         wait_on_value(BIT17|BIT16, 0, CM_MEMIF_EMIF_1_CLKCTRL, LDELAY);
705         sr32(CM_MEMIF_EMIF_2_CLKCTRL, 0, 32, 0x1);
706         wait_on_value(BIT17|BIT16, 0, CM_MEMIF_EMIF_2_CLKCTRL, LDELAY);
707         sr32(CM_D2D_CLKSTCTRL, 0, 32, 0x3);
708         sr32(CM_L3_2_GPMC_CLKCTRL, 0, 32, 0x1);
709         wait_on_value(BIT17|BIT16, 0, CM_L3_2_GPMC_CLKCTRL, LDELAY);
710         sr32(CM_L3INSTR_L3_3_CLKCTRL, 0, 32, 0x1);
711         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_L3_3_CLKCTRL, LDELAY);
712         sr32(CM_L3INSTR_L3_INSTR_CLKCTRL, 0, 32, 0x1);
713         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_L3_INSTR_CLKCTRL, LDELAY);
714         sr32(CM_L3INSTR_OCP_WP1_CLKCTRL, 0, 32, 0x1);
715         wait_on_value(BIT17|BIT16, 0, CM_L3INSTR_OCP_WP1_CLKCTRL, LDELAY);
716
717         /* WDT clocks */
718         sr32(CM_WKUP_WDT2_CLKCTRL, 0, 32, 0x2);
719         wait_on_value(BIT17|BIT16, 0, CM_WKUP_WDT2_CLKCTRL, LDELAY);
720
721         /* Enable Camera clocks */
722         sr32(CM_CAM_CLKSTCTRL, 0, 32, 0x3);
723         sr32(CM_CAM_ISS_CLKCTRL, 0, 32, 0x102);
724         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_CAM_ISS_CLKCTRL, LDELAY); */
725         sr32(CM_CAM_FDIF_CLKCTRL, 0, 32, 0x2);
726         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_CAM_FDIF_CLKCTRL, LDELAY); */
727         sr32(CM_CAM_CLKSTCTRL, 0, 32, 0x0);
728
729         /* Enable DSS clocks */
730         /* PM_DSS_PWRSTCTRL ON State and LogicState = 1 (Retention) */
731         *(volatile int *)0x4A307100 = 0x7; /* DSS_PRM */
732         sr32(CM_DSS_CLKSTCTRL, 0, 32, 0x2);
733         sr32(CM_DSS_DSS_CLKCTRL, 0, 32, 0xf02);
734         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_DSS_DSS_CLKCTRL, LDELAY); */
735         sr32(CM_DSS_DEISS_CLKCTRL, 0, 32, 0x2);
736         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_DSS_DEISS_CLKCTRL, LDELAY); */
737
738         /* Check for DSS Clocks */
739         while (((*(volatile int *)0x4A009100) & 0xF00) != 0xE00)
740                 /* Set HW_AUTO transition mode */
741                 sr32(CM_DSS_CLKSTCTRL, 0, 32, 0x3);
742
743         /* Enable SGX clocks */
744         sr32(CM_SGX_CLKSTCTRL, 0, 32, 0x2);
745         sr32(CM_SGX_SGX_CLKCTRL, 0, 32, 0x2);
746         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_SGX_SGX_CLKCTRL, LDELAY); */
747         /* Check for SGX FCLK and ICLK */
748         while ((*(volatile int *)0x4A009200) != 0x302)
749                 ;
750         /* sr32(CM_SGX_CLKSTCTRL, 0, 32, 0x0); */
751         /* Enable hsi/unipro/usb clocks */
752         sr32(CM_L3INIT_HSI_CLKCTRL, 0, 32, 0x1);
753         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSI_CLKCTRL,
754          *      LDELAY); */
755         sr32(CM_L3INIT_UNIPRO1_CLKCTRL, 0, 32, 0x2);
756         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_UNIPRO1_CLKCTRL,
757          *      LDELAY); */
758         sr32(CM_L3INIT_HSUSBHOST_CLKCTRL, 0, 32, 0x2);
759         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSUSBHOST_CLKCTRL,
760          *      LDELAY); */
761         sr32(CM_L3INIT_HSUSBOTG_CLKCTRL, 0, 32, 0x1);
762         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_HSUSBOTG_CLKCTRL,
763          *      LDELAY); */
764         sr32(CM_L3INIT_HSUSBTLL_CLKCTRL, 0, 32, 0x1);
765         /* wait_on_value(BIT17|BIT16, 0, CM_L3INIT_HSUSBTLL_CLKCTRL, LDELAY); */
766         sr32(CM_L3INIT_FSUSB_CLKCTRL, 0, 32, 0x2);
767         /* wait_on_value(BIT18|BIT17|BIT16, 0, CM_L3INIT_FSUSB_CLKCTRL,
768          *      LDELAY); */
769         /* enable the 32K, 48M optional clocks and enable the module */
770         sr32(CM_L3INIT_USBPHY_CLKCTRL, 0, 32, 0x301);
771         /* wait_on_value(BIT17|BIT16, 0, CM_L3INIT_USBPHY_CLKCTRL, LDELAY); */
772 }
773
774 /******************************************************************************
775  * prcm_init() - inits clocks for PRCM as defined in clocks.h
776  *   -- called from SRAM, or Flash (using temp SRAM stack).
777  *****************************************************************************/
778 void prcm_init(void)
779 {
780         u32 clk_index;
781
782         /* Get the sysclk speed from cm_sys_clksel
783          * Set the CM_SYS_CLKSEL in case ROM code has not set
784          */
785         __raw_writel(0x7, CM_SYS_CLKSEL);
786         clk_index = readl(CM_SYS_CLKSEL);
787         if (!clk_index)
788                 return; /* Sys clk uninitialized */
789         /* Core DPLL is locked using FREQ update method */
790         /* configure_core_dpll(clk_index - 1); */
791
792         /* Configure all DPLL's at 100% OPP */
793         configure_mpu_dpll(clk_index - 1);
794         configure_iva_dpll(clk_index - 1);
795         configure_per_dpll(clk_index - 1);
796         configure_abe_dpll(clk_index - 1);
797         configure_usb_dpll(clk_index - 1);
798
799 #ifdef CONFIG_OMAP4_SDC
800         /* Enable all clocks */
801         enable_all_clocks();
802 #endif
803 }