1b33421bf9cea1235280b2fabc762a3c0ff06821
[x-loader-sniper.git] / board / tam3517 / tam3517.c
1
2 #include <common.h>
3 #include <command.h>
4 #include <part.h>
5 #include <fat.h>
6 #include <asm/arch/cpu.h>
7 #include <asm/arch/bits.h>
8 #include <asm/arch/mux.h>
9 #include <asm/arch/sys_proto.h>
10 #include <asm/arch/sys_info.h>
11 #include <asm/arch/clocks.h>
12 #include <asm/arch/mem.h>
13
14 /* Used to index into DPLL parameter tables */
15 struct dpll_param {
16         unsigned int m;
17         unsigned int n;
18         unsigned int fsel;
19         unsigned int m2;
20 };
21
22 typedef struct dpll_param dpll_param;
23
24 #define MAX_SIL_INDEX   3
25
26 /* EMIF4 register defines */
27 #define EMIF4_BASE              OMAP34XX_SDRC_BASE
28 #define EMIF4_MOD_ID            (EMIF4_BASE + 0x00)
29 #define EMIF4_SDRAM_STS         (EMIF4_BASE + 0x04)
30 #define EMIF4_SDRAM_CFG         (EMIF4_BASE + 0x08)
31 #define EMIF4_SDRAM_RFCR        (EMIF4_BASE + 0x10)
32 #define EMIF4_SDRAM_RFCR_SHDW   (EMIF4_BASE + 0x14)
33 #define EMIF4_SDRAM_TIM1        (EMIF4_BASE + 0x18)
34 #define EMIF4_SDRAM_TIM1_SHDW   (EMIF4_BASE + 0x1C)
35 #define EMIF4_SDRAM_TIM2        (EMIF4_BASE + 0x20)
36 #define EMIF4_SDRAM_TIM2_SHDW   (EMIF4_BASE + 0x24)
37 #define EMIF4_SDRAM_TIM3        (EMIF4_BASE + 0x28)
38 #define EMIF4_SDRAM_TIM3_SHDW   (EMIF4_BASE + 0x2c)
39 #define EMIF4_PWR_MGT_CTRL      (EMIF4_BASE + 0x38)
40 #define EMIF4_PWR_MGT_CTRL_SHDW (EMIF4_BASE + 0x3C)
41 #define EMIF4_IODFT_TLGC        (EMIF4_BASE + 0x60)
42 #define EMIF4_DDR_PHYCTL1       (EMIF4_BASE + 0xE4)
43 #define EMIF4_DDR_PHYCTL1_SHDW  (EMIF4_BASE + 0xE8)
44 #define EMIF4_DDR_PHYCTL2       (EMIF4_BASE + 0xEC)
45
46 /* Definitions for EMIF4 configuration values */
47 #define EMIF4_TIM1_T_RP         0x3
48 #define EMIF4_TIM1_T_RCD        0x3
49 #define EMIF4_TIM1_T_WR         0x3
50 #define EMIF4_TIM1_T_RAS        0x8
51 #define EMIF4_TIM1_T_RC         0xA
52 #define EMIF4_TIM1_T_RRD        0x2
53 #define EMIF4_TIM1_T_WTR        0x2
54
55 #define EMIF4_TIM2_T_XP         0x2
56 #define EMIF4_TIM2_T_ODT        0x0
57 #define EMIF4_TIM2_T_XSNR       0x1C
58 #define EMIF4_TIM2_T_XSRD       0xC8
59 #define EMIF4_TIM2_T_RTP        0x1
60 #define EMIF4_TIM2_T_CKE        0x2
61
62 #define EMIF4_TIM3_T_TDQSCKMAX  0x0
63 #define EMIF4_TIM3_T_RFC        0x25
64 #define EMIF4_TIM3_T_RAS_MAX    0x7
65
66 #define EMIF4_PWR_IDLE          0x2
67 #define EMIF4_PWR_DPD_EN        0x0
68 #define EMIF4_PWR_PM_EN         0x0
69 #define EMIF4_PWR_PM_TIM        0x0
70
71 #define EMIF4_INITREF_DIS       0x0
72 #define EMIF4_PASR              0x0
73 #define EMIF4_REFRESH_RATE      0x50F
74
75 /*
76  * SDRAM Config register
77  */
78 #define EMIF4_CFG_SDRAM_TYP     0x2
79 #define EMIF4_CFG_IBANK_POS     0x0
80 #define EMIF4_CFG_DDR_TERM      0x0
81 #define EMIF4_CFG_DDR2_DDQS     0x1
82 #define EMIF4_CFG_DYN_ODT       0x0
83 #define EMIF4_CFG_DDR_DIS_DLL   0x0
84 #define EMIF4_CFG_SDR_DRV       0x0
85 #define EMIF4_CFG_CWL           0x0
86 #if CONFIG_DRAM_BUS_WIDTH == 16
87 #define EMIF4_CFG_NARROW_MD     0x1
88 #else
89 #define EMIF4_CFG_NARROW_MD     0x0
90 #endif
91 #define EMIF4_CFG_CL            0x5
92 #define EMIF4_CFG_ROWSIZE       0x4
93 #define EMIF4_CFG_IBANK         0x3
94 #define EMIF4_CFG_EBANK         0x0
95 #define EMIF4_CFG_PGSIZE        0x2
96
97 /*
98  * EMIF4 PHY Control 1 register configuration
99  */
100 #define EMIF4_DDR1_RD_LAT       0x6
101 #define EMIF4_DDR1_PWRDN_DIS    0x0
102 #define EMIF4_DDR1_STRBEN_EXT   0x0
103 #define EMIF4_DDR1_DLL_MODE     0x0
104 #define EMIF4_DDR1_VTP_DYN      0x0
105 #define EMIF4_DDR1_LB_CK_SEL    0x0
106
107 /*
108  * EMIF4 PHY Control 2 register configuration
109  */
110 #define EMIF4_DDR2_TX_DATA_ALIGN        0x0
111 #define EMIF4_DDR2_RX_DLL_BYPASS        0x0
112
113 #define OMAP34XX_CONTROL_ID              (OMAP34XX_WAKEUP_L4_IO_BASE + 0xa204)
114
115 /* Following functions are exported from lowlevel_init.S */
116 extern dpll_param *get_mpu_dpll_param(void);
117 extern dpll_param *get_core_dpll_param(void);
118 extern dpll_param *get_per_dpll_param(void);
119
120 extern int mmc_init(int verbose);
121 extern block_dev_desc_t *mmc_get_dev(int dev);
122
123 #define __raw_readl(a)    (*(volatile unsigned int *)(a))
124 #define __raw_writel(v,a) (*(volatile unsigned int *)(a) = (v))
125 #define __raw_readw(a)    (*(volatile unsigned short *)(a))
126 #define __raw_writew(v,a) (*(volatile unsigned short *)(a) = (v))
127
128 u32 is_cpu_family(void)
129 {
130         u32 cpuid = 0, cpu_family = 0;
131         u16 hawkeye;
132
133         cpuid = __raw_readl(OMAP34XX_CONTROL_ID);
134         hawkeye  = (cpuid >> HAWKEYE_SHIFT) & 0xffff;
135
136         switch (hawkeye) {
137         case HAWKEYE_AM35XX:
138         default:
139                 cpu_family = CPU_AM35XX;
140                 break;
141         }
142         return cpu_family;
143 }
144
145 /*******************************************************
146  * Routine: delay
147  * Description: spinning delay to use before udelay works
148  ******************************************************/
149 static inline void delay(unsigned long loops)
150 {
151         __asm__ volatile ("1:\n" "subs %0, %1, #1\n"
152                           "bne 1b":"=r" (loops):"0"(loops));
153 }
154
155 /*****************************************
156  * Routine: board_init
157  * Description: Early hardware init.
158  *****************************************/
159 int board_init (void)
160 {
161         return 0;
162 }
163
164 /*************************************************************
165  *  get_device_type(): tell if GP/HS/EMU/TST
166  *************************************************************/
167 u32 get_device_type(void)
168 {
169         int mode;
170         mode = __raw_readl(CONTROL_STATUS) & (DEVICE_MASK);
171         return(mode >>= 8);
172 }
173
174 /************************************************
175  * get_sysboot_value(void) - return SYS_BOOT[4:0]
176  ************************************************/
177 u32 get_sysboot_value(void)
178 {
179         int mode;
180         mode = __raw_readl(CONTROL_STATUS) & (SYSBOOT_MASK);
181         return mode;
182 }
183 /*************************************************************
184  * Routine: get_mem_type(void) - returns the kind of memory connected
185  * to GPMC that we are trying to boot form. Uses SYS BOOT settings.
186  *************************************************************/
187 u32 get_mem_type(void)
188 {
189         u32   mem_type = get_sysboot_value();
190         switch (mem_type) {
191         case 0:
192         case 2:
193         case 4:
194         case 16:
195         case 22:
196                 return GPMC_ONENAND;
197
198         case 1:
199         case 12:
200         case 15:
201         case 21:
202         case 27:
203                 return GPMC_NAND;
204
205         case 3:
206         case 6:
207                 return MMC_ONENAND;
208
209         case 8:
210         case 11:
211         case 14:
212         case 20:
213         case 26:
214                 return GPMC_MDOC;
215
216         case 17:
217         case 18:
218         case 24:
219                 return MMC_NAND;
220
221         case 7:
222         case 10:
223         case 13:
224         case 19:
225         case 25:
226         default:
227                 return GPMC_NOR;
228         }
229 }
230
231 /******************************************
232  * get_cpu_rev(void) - extract version info
233  ******************************************/
234 u32 get_cpu_rev(void)
235 {
236         u32 cpuid = 0;
237         /* On ES1.0 the IDCODE register is not exposed on L4
238          * so using CPU ID to differentiate
239          * between ES2.0 and ES1.0.
240          */
241         __asm__ __volatile__("mrc p15, 0, %0, c0, c0, 0":"=r" (cpuid));
242         if ((cpuid & 0xf) == 0x0)
243                 return CPU_3430_ES1;
244         else
245                 return CPU_3430_ES2;
246
247 }
248
249 /******************************************
250  * cpu_is_3410(void) - returns true for 3410
251  ******************************************/
252 u32 cpu_is_3410(void)
253 {
254         int status;
255         if (get_cpu_rev() < CPU_3430_ES2) {
256                 return 0;
257         } else {
258                 /* read scalability status and return 1 for 3410*/
259                 status = __raw_readl(CONTROL_SCALABLE_OMAP_STATUS);
260                 /* Check whether MPU frequency is set to 266 MHz which
261                  * is nominal for 3410. If yes return true else false
262                  */
263                 if (((status >> 8) & 0x3) == 0x2)
264                         return 1;
265                 else
266                         return 0;
267         }
268 }
269
270 /*****************************************************************
271  * sr32 - clear & set a value in a bit range for a 32 bit address
272  *****************************************************************/
273 void sr32(u32 addr, u32 start_bit, u32 num_bits, u32 value)
274 {
275         u32 tmp, msk = 0;
276         msk = 1 << num_bits;
277         --msk;
278         tmp = __raw_readl(addr) & ~(msk << start_bit);
279         tmp |=  value << start_bit;
280         __raw_writel(tmp, addr);
281 }
282
283 /*********************************************************************
284  * wait_on_value() - common routine to allow waiting for changes in
285  *   volatile regs.
286  *********************************************************************/
287 u32 wait_on_value(u32 read_bit_mask, u32 match_value, u32 read_addr, u32 bound)
288 {
289         u32 i = 0, val;
290         do {
291                 ++i;
292                 val = __raw_readl(read_addr) & read_bit_mask;
293                 if (val == match_value)
294                         return 1;
295                 if (i == bound)
296                         return 0;
297         } while (1);
298 }
299
300 /*********************************************************************
301  * config_emif4_ddr() - Init/Configure DDR on AM3517 EVM board.
302  *********************************************************************/
303 void config_emif4_ddr(void)
304 {
305         unsigned int regval;
306
307         /* Set the DDR PHY parameters in PHY ctrl registers */
308         regval = (EMIF4_DDR1_RD_LAT | (EMIF4_DDR1_PWRDN_DIS << 6) |
309                 (EMIF4_DDR1_STRBEN_EXT << 7) | (EMIF4_DDR1_DLL_MODE << 12) |
310                 (EMIF4_DDR1_VTP_DYN << 15) | (EMIF4_DDR1_LB_CK_SEL << 23));
311         __raw_writel(regval, EMIF4_DDR_PHYCTL1);
312         __raw_writel(regval, EMIF4_DDR_PHYCTL1_SHDW);
313
314         regval = (EMIF4_DDR2_TX_DATA_ALIGN | (EMIF4_DDR2_RX_DLL_BYPASS << 1));
315         __raw_writel(regval, EMIF4_DDR_PHYCTL2);
316
317         /* Reset the DDR PHY and wait till completed */
318         sr32(EMIF4_IODFT_TLGC, 10, 1, 1);
319         /*Wait till that bit clears*/
320         while ((__raw_readl(EMIF4_IODFT_TLGC) & BIT10) == 0x1);
321         /*Re-verify the DDR PHY status*/
322         while ((__raw_readl(EMIF4_SDRAM_STS) & BIT2) == 0x0);
323
324         sr32(EMIF4_IODFT_TLGC, 0, 1, 1);
325         /* Set SDR timing registers */
326         regval = (EMIF4_TIM1_T_WTR | (EMIF4_TIM1_T_RRD << 3) |
327                 (EMIF4_TIM1_T_RC << 6) | (EMIF4_TIM1_T_RAS << 12) |
328                 (EMIF4_TIM1_T_WR << 17) | (EMIF4_TIM1_T_RCD << 21) |
329                 (EMIF4_TIM1_T_RP << 25));
330         __raw_writel(regval, EMIF4_SDRAM_TIM1);
331         __raw_writel(regval, EMIF4_SDRAM_TIM1_SHDW);
332
333         regval = (EMIF4_TIM2_T_CKE | (EMIF4_TIM2_T_RTP << 3) |
334                 (EMIF4_TIM2_T_XSRD << 6) | (EMIF4_TIM2_T_XSNR << 16) |
335                 (EMIF4_TIM2_T_ODT << 25) | (EMIF4_TIM2_T_XP << 28));
336         __raw_writel(regval, EMIF4_SDRAM_TIM2);
337         __raw_writel(regval, EMIF4_SDRAM_TIM2_SHDW);
338
339         regval = (EMIF4_TIM3_T_RAS_MAX | (EMIF4_TIM3_T_RFC << 4) |
340                 (EMIF4_TIM3_T_TDQSCKMAX << 13));
341         __raw_writel(regval, EMIF4_SDRAM_TIM3);
342         __raw_writel(regval, EMIF4_SDRAM_TIM3_SHDW);
343
344         /* Set the PWR control register */
345         regval = (EMIF4_PWR_PM_TIM | (EMIF4_PWR_PM_EN << 8) |
346                 (EMIF4_PWR_DPD_EN << 10) | (EMIF4_PWR_IDLE << 30));
347         __raw_writel(regval, EMIF4_PWR_MGT_CTRL);
348         __raw_writel(regval, EMIF4_PWR_MGT_CTRL_SHDW);
349
350         /* Set the DDR refresh rate control register */
351         regval = (EMIF4_REFRESH_RATE | (EMIF4_PASR << 24) |
352                 (EMIF4_INITREF_DIS << 31));
353         __raw_writel(regval, EMIF4_SDRAM_RFCR);
354         __raw_writel(regval, EMIF4_SDRAM_RFCR_SHDW);
355
356         /* set the SDRAM configuration register */
357         regval = (EMIF4_CFG_PGSIZE | (EMIF4_CFG_EBANK << 3) |
358                 (EMIF4_CFG_IBANK << 4) | (EMIF4_CFG_ROWSIZE << 7) |
359                 (EMIF4_CFG_CL << 10) | (EMIF4_CFG_NARROW_MD << 14) |
360                 (EMIF4_CFG_CWL << 16) | (EMIF4_CFG_SDR_DRV << 18) |
361                 (EMIF4_CFG_DDR_DIS_DLL << 20) | (EMIF4_CFG_DYN_ODT << 21) |
362                 (EMIF4_CFG_DDR2_DDQS << 23) | (EMIF4_CFG_DDR_TERM << 24) |
363                 (EMIF4_CFG_IBANK_POS << 27) | (EMIF4_CFG_SDRAM_TYP << 29));
364         __raw_writel(regval, EMIF4_SDRAM_CFG);
365 }
366
367 /*************************************************************
368  * get_sys_clk_speed - determine reference oscillator speed
369  *  based on known 32kHz clock and gptimer.
370  *************************************************************/
371 u32 get_osc_clk_speed(void)
372 {
373         u32 start, cstart, cend, cdiff, cdiv, val;
374
375         val = __raw_readl(PRM_CLKSRC_CTRL);
376
377         if (val & SYSCLKDIV_2)
378                 cdiv = 2;
379         else
380                 cdiv = 1;
381
382         /* enable timer2 */
383         val = __raw_readl(CM_CLKSEL_WKUP) | BIT0;
384         __raw_writel(val, CM_CLKSEL_WKUP);      /* select sys_clk for GPT1 */
385
386         /* Enable I and F Clocks for GPT1 */
387         val = __raw_readl(CM_ICLKEN_WKUP) | BIT0 | BIT2;
388         __raw_writel(val, CM_ICLKEN_WKUP);
389         val = __raw_readl(CM_FCLKEN_WKUP) | BIT0;
390         __raw_writel(val, CM_FCLKEN_WKUP);
391
392         __raw_writel(0, OMAP34XX_GPT1 + TLDR);          /* start counting at 0 */
393         __raw_writel(GPT_EN, OMAP34XX_GPT1 + TCLR);     /* enable clock */
394         /* enable 32kHz source */
395         /* enabled out of reset */
396         /* determine sys_clk via gauging */
397
398         start = 20 + __raw_readl(S32K_CR);      /* start time in 20 cycles */
399         while (__raw_readl(S32K_CR) < start) ;  /* dead loop till start time */
400         cstart = __raw_readl(OMAP34XX_GPT1 + TCRR);     /* get start sys_clk count */
401         while (__raw_readl(S32K_CR) < (start + 20)) ;   /* wait for 40 cycles */
402         cend = __raw_readl(OMAP34XX_GPT1 + TCRR);       /* get end sys_clk count */
403         cdiff = cend - cstart;  /* get elapsed ticks */
404         cdiff *= cdiv;
405
406         /* based on number of ticks assign speed */
407         if (cdiff > 19000)
408                 return S38_4M;
409         else if (cdiff > 15200)
410                 return S26M;
411         else if (cdiff > 13000)
412                 return S24M;
413         else if (cdiff > 9000)
414                 return S19_2M;
415         else if (cdiff > 7600)
416                 return S13M;
417         else
418                 return S12M;
419 }
420
421 /******************************************************************************
422  * get_sys_clkin_sel() - returns the sys_clkin_sel field value based on
423  *   -- input oscillator clock frequency.
424  *
425  *****************************************************************************/
426 void get_sys_clkin_sel(u32 osc_clk, u32 *sys_clkin_sel)
427 {
428         if(osc_clk == S38_4M)
429                 *sys_clkin_sel=  4;
430         else if(osc_clk == S26M)
431                 *sys_clkin_sel = 3;
432         else if(osc_clk == S19_2M)
433                 *sys_clkin_sel = 2;
434         else if(osc_clk == S13M)
435                 *sys_clkin_sel = 1;
436         else if(osc_clk == S12M)
437                 *sys_clkin_sel = 0;
438 }
439
440 /******************************************************************************
441  * prcm_init() - inits clocks for PRCM as defined in clocks.h
442  *   -- called from SRAM, or Flash (using temp SRAM stack).
443  *****************************************************************************/
444 void prcm_init(void)
445 {
446         u32 osc_clk=0, sys_clkin_sel;
447         dpll_param *dpll_param_p;
448         u32 clk_index, sil_index;
449
450         /* Gauge the input clock speed and find out the sys_clkin_sel
451          * value corresponding to the input clock.
452          */
453         osc_clk = S26M; //get_osc_clk_speed();
454         get_sys_clkin_sel(osc_clk, &sys_clkin_sel);
455
456         sr32(PRM_CLKSEL, 0, 3, sys_clkin_sel); /* set input crystal speed */
457
458         /* If the input clock is greater than 19.2M always divide/2 */
459         if(sys_clkin_sel > 2) {
460                 sr32(PRM_CLKSRC_CTRL, 6, 2, 2);/* input clock divider */
461                 clk_index = sys_clkin_sel/2;
462         } else {
463                 sr32(PRM_CLKSRC_CTRL, 6, 2, 1);/* input clock divider */
464                 clk_index = sys_clkin_sel;
465         }
466
467         sr32(PRM_CLKSRC_CTRL, 0, 2, 0);/* Bypass mode: T2 inputs a square clk*/
468
469         /* The DPLL tables are defined according to sysclk value and
470          * silicon revision. The clk_index value will be used to get
471          * the values for that input sysclk from the DPLL param table
472          * and sil_index will get the values for that SysClk for the
473          * appropriate silicon rev.
474          */
475         sil_index = get_cpu_rev() - 1;
476
477         /* Unlock MPU DPLL (slows things down, and needed later) */
478         sr32(CM_CLKEN_PLL_MPU, 0, 3, PLL_LOW_POWER_BYPASS);
479         wait_on_value(BIT0, 0, CM_IDLEST_PLL_MPU, LDELAY);
480
481         /* Getting the base address of Core DPLL param table*/
482         dpll_param_p = (dpll_param *)get_core_dpll_param();
483         /* Moving it to the right sysclk and ES rev base */
484         dpll_param_p = dpll_param_p + 2*clk_index + sil_index;
485         /* CORE DPLL */
486         /* sr32(CM_CLKSEL2_EMU) set override to work when asleep */
487         sr32(CM_CLKEN_PLL, 0, 3, PLL_FAST_RELOCK_BYPASS);
488         wait_on_value(BIT0, 0, CM_IDLEST_CKGEN, LDELAY);
489         sr32(CM_CLKSEL1_EMU, 16, 5, CORE_M3X2); /* m3x2 */
490         sr32(CM_CLKSEL1_PLL, 27, 2, dpll_param_p->m2);  /* Set M2 */
491         sr32(CM_CLKSEL1_PLL, 16, 11, dpll_param_p->m);  /* Set M */
492         sr32(CM_CLKSEL1_PLL, 8, 7, dpll_param_p->n);    /* Set N */
493         sr32(CM_CLKSEL1_PLL, 6, 1, 0);                  /* 96M Src */
494         sr32(CM_CLKSEL_CORE, 2, 2, CORE_L4_DIV);        /* l4 */
495         sr32(CM_CLKSEL_CORE, 0, 2, CORE_L3_DIV);        /* l3 */
496         sr32(CM_CLKSEL_WKUP, 1, 2, WKUP_RSM);           /* reset mgr */
497         sr32(CM_CLKEN_PLL, 4, 4, dpll_param_p->fsel);   /* FREQSEL */
498         sr32(CM_CLKEN_PLL, 0, 3, PLL_LOCK);             /* lock mode */
499         wait_on_value(BIT0, 1, CM_IDLEST_CKGEN, LDELAY);
500
501         /* Getting the base address to PER  DPLL param table*/
502         dpll_param_p = (dpll_param *)get_per_dpll_param();
503         /* Moving it to the right sysclk base */
504         dpll_param_p = dpll_param_p + clk_index;
505         /* PER DPLL */
506         sr32(CM_CLKEN_PLL, 16, 3, PLL_STOP);
507         wait_on_value(BIT1, 0, CM_IDLEST_CKGEN, LDELAY);
508         sr32(CM_CLKSEL1_EMU, 24, 5, PER_M6X2);  /* set M6 */
509         sr32(CM_CLKSEL_CAM, 0, 5, PER_M5X2);    /* set M5 */
510         sr32(CM_CLKSEL_DSS, 0, 5, PER_M4X2);    /* set M4 */
511         sr32(CM_CLKSEL_DSS, 8, 5, PER_M3X2);    /* set M3 */
512         sr32(CM_CLKSEL3_PLL, 0, 5, dpll_param_p->m2);   /* set M2 */
513         sr32(CM_CLKSEL2_PLL, 8, 11, dpll_param_p->m);   /* set m */
514         sr32(CM_CLKSEL2_PLL, 0, 7, dpll_param_p->n);    /* set n */
515         sr32(CM_CLKEN_PLL, 20, 4, dpll_param_p->fsel);/* FREQSEL */
516         sr32(CM_CLKEN_PLL, 16, 3, PLL_LOCK);    /* lock mode */
517         wait_on_value(BIT1, 2, CM_IDLEST_CKGEN, LDELAY);
518
519         /* Getting the base address to MPU DPLL param table*/
520         dpll_param_p = (dpll_param *)get_mpu_dpll_param();
521         /* Moving it to the right sysclk and ES rev base */
522         dpll_param_p = dpll_param_p + 2*clk_index + sil_index;
523         /* MPU DPLL (unlocked already) */
524         sr32(CM_CLKSEL2_PLL_MPU, 0, 5, dpll_param_p->m2); /* Set M2 */
525         sr32(CM_CLKSEL1_PLL_MPU, 8, 11, dpll_param_p->m); /* Set M */
526         sr32(CM_CLKSEL1_PLL_MPU, 0, 7, dpll_param_p->n);  /* Set N */
527         sr32(CM_CLKEN_PLL_MPU, 4, 4, dpll_param_p->fsel); /* FREQSEL */
528         sr32(CM_CLKEN_PLL_MPU, 0, 3, PLL_LOCK); /* lock mode */
529         wait_on_value(BIT0, 1, CM_IDLEST_PLL_MPU, LDELAY);
530
531         /* Set up GPTimers to sys_clk source only */
532         sr32(CM_CLKSEL_PER, 0, 8, 0xff);
533         sr32(CM_CLKSEL_WKUP, 0, 1, 1);
534
535         delay(5000);
536 }
537
538 /*****************************************
539  * Routine: secure_unlock
540  * Description: Setup security registers for access
541  * (GP Device only)
542  *****************************************/
543 void secure_unlock(void)
544 {
545         /* Permission values for registers
546           -Full fledged permissions to all */
547         #define UNLOCK_1 0xFFFFFFFF
548         #define UNLOCK_2 0x00000000
549         #define UNLOCK_3 0x0000FFFF
550         /* Protection Module Register Target APE (PM_RT)*/
551         __raw_writel(UNLOCK_1, RT_REQ_INFO_PERMISSION_1);
552         __raw_writel(UNLOCK_1, RT_READ_PERMISSION_0);
553         __raw_writel(UNLOCK_1, RT_WRITE_PERMISSION_0);
554         __raw_writel(UNLOCK_2, RT_ADDR_MATCH_1);
555
556         __raw_writel(UNLOCK_3, GPMC_REQ_INFO_PERMISSION_0);
557         __raw_writel(UNLOCK_3, GPMC_READ_PERMISSION_0);
558         __raw_writel(UNLOCK_3, GPMC_WRITE_PERMISSION_0);
559
560         __raw_writel(UNLOCK_3, OCM_REQ_INFO_PERMISSION_0);
561         __raw_writel(UNLOCK_3, OCM_READ_PERMISSION_0);
562         __raw_writel(UNLOCK_3, OCM_WRITE_PERMISSION_0);
563         __raw_writel(UNLOCK_2, OCM_ADDR_MATCH_2);
564
565         /* IVA Changes */
566         __raw_writel(UNLOCK_3, IVA2_REQ_INFO_PERMISSION_0);
567         __raw_writel(UNLOCK_3, IVA2_READ_PERMISSION_0);
568         __raw_writel(UNLOCK_3, IVA2_WRITE_PERMISSION_0);
569
570         __raw_writel(UNLOCK_1, SMS_RG_ATT0); /* SDRC region 0 public */
571 }
572
573 /**********************************************************
574  * Routine: try_unlock_sram()
575  * Description: If chip is GP type, unlock the SRAM for
576  *  general use.
577  ***********************************************************/
578 void try_unlock_memory(void)
579 {
580         int mode;
581
582         /* if GP device unlock device SRAM for general use */
583         /* secure code breaks for Secure/Emulation device - HS/E/T*/
584         mode = get_device_type();
585         if (mode == GP_DEVICE) {
586                 secure_unlock();
587         }
588         return;
589 }
590
591 /**********************************************************
592  * Routine: s_init
593  * Description: Does early system init of muxing and clocks.
594  * - Called at time when only stack is available.
595  **********************************************************/
596
597 void s_init(void)
598 {
599         watchdog_init();
600 #ifdef CONFIG_3430_AS_3410
601         /* setup the scalability control register for
602          * 3430 to work in 3410 mode
603          */
604         __raw_writel(0x5ABF,CONTROL_SCALABLE_OMAP_OCP);
605 #endif
606         try_unlock_memory();
607         set_muxconf_regs();
608         delay(100);
609         prcm_init();
610         per_clocks_enable();
611
612         /* enable the DDRPHY clk */
613         sr32((OMAP34XX_CTRL_BASE + 0x588), 15, 15, 0x1);
614         /* enable the EMIF4 clk */
615         sr32((OMAP34XX_CTRL_BASE + 0x588), 14, 14, 0x1);
616         /* Enable the peripheral clocks */
617         sr32((OMAP34XX_CTRL_BASE + 0x59C), 0, 4, 0xF);
618         sr32((OMAP34XX_CTRL_BASE + 0x59C), 8, 10, 0x7);
619
620         /* bring cpgmac out of reset */
621         sr32((OMAP34XX_CTRL_BASE + 0x598), 1, 1, 0x1);
622
623         /* Configure the EMIF4 for our DDR */
624         config_emif4_ddr();
625 }
626
627 /*******************************************************
628  * Routine: misc_init_r
629  * Description: Init ethernet (done here so udelay works)
630  ********************************************************/
631 int misc_init_r (void)
632 {
633         return(0);
634 }
635
636 /******************************************************
637  * Routine: wait_for_command_complete
638  * Description: Wait for posting to finish on watchdog
639  ******************************************************/
640 void wait_for_command_complete(unsigned int wd_base)
641 {
642         int pending = 1;
643         do {
644                 pending = __raw_readl(wd_base + WWPS);
645         } while (pending);
646 }
647
648 /****************************************
649  * Routine: watchdog_init
650  * Description: Shut down watch dogs
651  *****************************************/
652 void watchdog_init(void)
653 {
654         /* There are 3 watch dogs WD1=Secure, WD2=MPU, WD3=IVA. WD1 is
655          * either taken care of by ROM (HS/EMU) or not accessible (GP).
656          * We need to take care of WD2-MPU or take a PRCM reset.  WD3
657          * should not be running and does not generate a PRCM reset.
658          */
659         sr32(CM_FCLKEN_WKUP, 5, 1, 1);
660         sr32(CM_ICLKEN_WKUP, 5, 1, 1);
661         wait_on_value(BIT5, 0x20, CM_IDLEST_WKUP, 5); /* some issue here */
662
663         __raw_writel(WD_UNLOCK1, WD2_BASE + WSPR);
664         wait_for_command_complete(WD2_BASE);
665         __raw_writel(WD_UNLOCK2, WD2_BASE + WSPR);
666 }
667
668 /**********************************************
669  * Routine: dram_init
670  * Description: sets uboots idea of sdram size
671  **********************************************/
672 int dram_init (void)
673 {
674         return 0;
675 }
676
677 /*****************************************************************
678  * Routine: peripheral_enable
679  * Description: Enable the clks & power for perifs (GPT2, UART1,...)
680  ******************************************************************/
681 void per_clocks_enable(void)
682 {
683         /* Enable GP2 timer. */
684         sr32(CM_CLKSEL_PER, 0, 1, 0x1); /* GPT2 = sys clk */
685         sr32(CM_ICLKEN_PER, 3, 1, 0x1); /* ICKen GPT2 */
686         sr32(CM_FCLKEN_PER, 3, 1, 0x1); /* FCKen GPT2 */
687
688 #ifdef CFG_NS16550
689         /* Enable UART1 clocks */
690         sr32(CM_FCLKEN1_CORE, 13, 1, 0x1);
691         sr32(CM_ICLKEN1_CORE, 13, 1, 0x1);
692
693         /* Enable UART2 clocks */
694         sr32(CM_FCLKEN1_CORE, 14, 1, 0x1);
695         sr32(CM_ICLKEN1_CORE, 14, 1, 0x1);
696
697         /* Enable UART2 clocks */
698         sr32(CM_FCLKEN_PER, 11, 1, 0x1);
699         sr32(CM_ICLKEN_PER, 11, 1, 0x1);
700 #endif
701         /* Enable MMC1 clocks */
702         sr32(CM_FCLKEN1_CORE, 24, 1, 0x1);
703         sr32(CM_ICLKEN1_CORE, 24, 1, 0x1);
704
705         /* Enable MMC2 clocks */
706         sr32(CM_FCLKEN1_CORE, 25, 1, 0x1);
707         sr32(CM_ICLKEN1_CORE, 25, 1, 0x1);
708
709         delay(1000);
710 }
711
712 /* Set MUX for UART, GPMC, SDRC, GPIO */
713
714 #define         MUX_VAL(OFFSET,VALUE)\
715                 __raw_writew((VALUE), OMAP34XX_CTRL_BASE + (OFFSET));
716
717 #define         CP(x)   (CONTROL_PADCONF_##x)
718 /*
719  * IEN  - Input Enable
720  * IDIS - Input Disable
721  * PTD  - Pull type Down
722  * PTU  - Pull type Up
723  * DIS  - Pull type selection is inactive
724  * EN   - Pull type selection is active
725  * M0   - Mode 0
726  * The commented string gives the final mux configuration for that pin
727  */
728 #define MUX_DEFAULT()\
729         MUX_VAL(CP(SDRC_D0),        (IEN  | PTD | DIS | M0)) /*SDRC_D0*/\
730         MUX_VAL(CP(SDRC_D1),        (IEN  | PTD | DIS | M0)) /*SDRC_D1*/\
731         MUX_VAL(CP(SDRC_D2),        (IEN  | PTD | DIS | M0)) /*SDRC_D2*/\
732         MUX_VAL(CP(SDRC_D3),        (IEN  | PTD | DIS | M0)) /*SDRC_D3*/\
733         MUX_VAL(CP(SDRC_D4),        (IEN  | PTD | DIS | M0)) /*SDRC_D4*/\
734         MUX_VAL(CP(SDRC_D5),        (IEN  | PTD | DIS | M0)) /*SDRC_D5*/\
735         MUX_VAL(CP(SDRC_D6),        (IEN  | PTD | DIS | M0)) /*SDRC_D6*/\
736         MUX_VAL(CP(SDRC_D7),        (IEN  | PTD | DIS | M0)) /*SDRC_D7*/\
737         MUX_VAL(CP(SDRC_D8),        (IEN  | PTD | DIS | M0)) /*SDRC_D8*/\
738         MUX_VAL(CP(SDRC_D9),        (IEN  | PTD | DIS | M0)) /*SDRC_D9*/\
739         MUX_VAL(CP(SDRC_D10),       (IEN  | PTD | DIS | M0)) /*SDRC_D10*/\
740         MUX_VAL(CP(SDRC_D11),       (IEN  | PTD | DIS | M0)) /*SDRC_D11*/\
741         MUX_VAL(CP(SDRC_D12),       (IEN  | PTD | DIS | M0)) /*SDRC_D12*/\
742         MUX_VAL(CP(SDRC_D13),       (IEN  | PTD | DIS | M0)) /*SDRC_D13*/\
743         MUX_VAL(CP(SDRC_D14),       (IEN  | PTD | DIS | M0)) /*SDRC_D14*/\
744         MUX_VAL(CP(SDRC_D15),       (IEN  | PTD | DIS | M0)) /*SDRC_D15*/\
745         MUX_VAL(CP(SDRC_D16),       (IEN  | PTD | DIS | M0)) /*SDRC_D16*/\
746         MUX_VAL(CP(SDRC_D17),       (IEN  | PTD | DIS | M0)) /*SDRC_D17*/\
747         MUX_VAL(CP(SDRC_D18),       (IEN  | PTD | DIS | M0)) /*SDRC_D18*/\
748         MUX_VAL(CP(SDRC_D19),       (IEN  | PTD | DIS | M0)) /*SDRC_D19*/\
749         MUX_VAL(CP(SDRC_D20),       (IEN  | PTD | DIS | M0)) /*SDRC_D20*/\
750         MUX_VAL(CP(SDRC_D21),       (IEN  | PTD | DIS | M0)) /*SDRC_D21*/\
751         MUX_VAL(CP(SDRC_D22),       (IEN  | PTD | DIS | M0)) /*SDRC_D22*/\
752         MUX_VAL(CP(SDRC_D23),       (IEN  | PTD | DIS | M0)) /*SDRC_D23*/\
753         MUX_VAL(CP(SDRC_D24),       (IEN  | PTD | DIS | M0)) /*SDRC_D24*/\
754         MUX_VAL(CP(SDRC_D25),       (IEN  | PTD | DIS | M0)) /*SDRC_D25*/\
755         MUX_VAL(CP(SDRC_D26),       (IEN  | PTD | DIS | M0)) /*SDRC_D26*/\
756         MUX_VAL(CP(SDRC_D27),       (IEN  | PTD | DIS | M0)) /*SDRC_D27*/\
757         MUX_VAL(CP(SDRC_D28),       (IEN  | PTD | DIS | M0)) /*SDRC_D28*/\
758         MUX_VAL(CP(SDRC_D29),       (IEN  | PTD | DIS | M0)) /*SDRC_D29*/\
759         MUX_VAL(CP(SDRC_D30),       (IEN  | PTD | DIS | M0)) /*SDRC_D30*/\
760         MUX_VAL(CP(SDRC_D31),       (IEN  | PTD | DIS | M0)) /*SDRC_D31*/\
761         MUX_VAL(CP(SDRC_CLK),       (IEN  | PTD | DIS | M0)) /*SDRC_CLK*/\
762         MUX_VAL(CP(SDRC_DQS0),      (IEN  | PTD | DIS | M0)) /*SDRC_DQS0*/\
763         MUX_VAL(CP(SDRC_DQS1),      (IEN  | PTD | DIS | M0)) /*SDRC_DQS1*/\
764         MUX_VAL(CP(SDRC_DQS2),      (IEN  | PTD | DIS | M0)) /*SDRC_DQS2*/\
765         MUX_VAL(CP(SDRC_DQS3),      (IEN  | PTD | DIS | M0)) /*SDRC_DQS3*/\
766         MUX_VAL(CP(sdrc_cke0),      (M0)) /*SDRC_CKE0*/\
767         MUX_VAL(CP(sdrc_cke1),      (M0)) /*SDRC_CKE1*/\
768         MUX_VAL(CP(GPMC_A1),        (IDIS | PTD | DIS | M0)) /*GPMC_A1*/\
769         MUX_VAL(CP(GPMC_A2),        (IDIS | PTD | DIS | M0)) /*GPMC_A2*/\
770         MUX_VAL(CP(GPMC_A3),        (IDIS | PTD | DIS | M0)) /*GPMC_A3*/\
771         MUX_VAL(CP(GPMC_A4),        (IDIS | PTD | DIS | M0)) /*GPMC_A4*/\
772         MUX_VAL(CP(GPMC_A5),        (IDIS | PTD | DIS | M0)) /*GPMC_A5*/\
773         MUX_VAL(CP(GPMC_A6),        (IDIS | PTD | DIS | M0)) /*GPMC_A6*/\
774         MUX_VAL(CP(GPMC_A7),        (IDIS | PTD | DIS | M0)) /*GPMC_A7*/\
775         MUX_VAL(CP(GPMC_A8),        (IDIS | PTD | DIS | M0)) /*GPMC_A8*/\
776         MUX_VAL(CP(GPMC_A9),        (IDIS | PTD | DIS | M0)) /*GPMC_A9*/\
777         MUX_VAL(CP(GPMC_A10),       (IDIS | PTD | DIS | M0)) /*GPMC_A10*/\
778         MUX_VAL(CP(GPMC_D0),        (IEN  | PTD | DIS | M0)) /*GPMC_D0*/\
779         MUX_VAL(CP(GPMC_D1),        (IEN  | PTD | DIS | M0)) /*GPMC_D1*/\
780         MUX_VAL(CP(GPMC_D2),        (IEN  | PTD | DIS | M0)) /*GPMC_D2*/\
781         MUX_VAL(CP(GPMC_D3),        (IEN  | PTD | DIS | M0)) /*GPMC_D3*/\
782         MUX_VAL(CP(GPMC_D4),        (IEN  | PTD | DIS | M0)) /*GPMC_D4*/\
783         MUX_VAL(CP(GPMC_D5),        (IEN  | PTD | DIS | M0)) /*GPMC_D5*/\
784         MUX_VAL(CP(GPMC_D6),        (IEN  | PTD | DIS | M0)) /*GPMC_D6*/\
785         MUX_VAL(CP(GPMC_D7),        (IEN  | PTD | DIS | M0)) /*GPMC_D7*/\
786         MUX_VAL(CP(GPMC_D8),        (IEN  | PTD | DIS | M0)) /*GPMC_D8*/\
787         MUX_VAL(CP(GPMC_D9),        (IEN  | PTD | DIS | M0)) /*GPMC_D9*/\
788         MUX_VAL(CP(GPMC_D10),       (IEN  | PTD | DIS | M0)) /*GPMC_D10*/\
789         MUX_VAL(CP(GPMC_D11),       (IEN  | PTD | DIS | M0)) /*GPMC_D11*/\
790         MUX_VAL(CP(GPMC_D12),       (IEN  | PTD | DIS | M0)) /*GPMC_D12*/\
791         MUX_VAL(CP(GPMC_D13),       (IEN  | PTD | DIS | M0)) /*GPMC_D13*/\
792         MUX_VAL(CP(GPMC_D14),       (IEN  | PTD | DIS | M0)) /*GPMC_D14*/\
793         MUX_VAL(CP(GPMC_D15),       (IEN  | PTD | DIS | M0)) /*GPMC_D15*/\
794         MUX_VAL(CP(GPMC_nCS0),      (IDIS | PTU | EN  | M0)) /*GPMC_nCS0*/\
795         MUX_VAL(CP(GPMC_nCS1),      (IDIS | PTU | EN  | M0)) /*GPMC_nCS1*/\
796         MUX_VAL(CP(GPMC_nCS2),      (IDIS | PTU | EN  | M0)) /*GPMC_nCS2*/\
797         MUX_VAL(CP(GPMC_nCS3),      (IDIS | PTU | EN  | M0)) /*GPMC_nCS3*/\
798         MUX_VAL(CP(GPMC_nCS4),      (IDIS | PTU | EN  | M0)) /*GPMC_nCS4*/\
799         MUX_VAL(CP(GPMC_nCS5),      (IDIS | PTU | EN  | M0)) /*GPMC_nCS5*/\
800         MUX_VAL(CP(GPMC_nCS6),      (IDIS | PTD | EN | M4)) /*GPMC_nCS6*/\
801         MUX_VAL(CP(GPMC_nCS7),      (IDIS | PTD | EN  | M4)) /*GPMC_nCS7*/\
802         MUX_VAL(CP(GPMC_CLK),       (IDIS | PTD | DIS | M0)) /*GPMC_CLK*/\
803         MUX_VAL(CP(GPMC_nADV_ALE),  (IDIS | PTD | DIS | M0)) /*GPMC_nADV_ALE*/\
804         MUX_VAL(CP(GPMC_nOE),       (IDIS | PTD | DIS | M0)) /*GPMC_nOE*/\
805         MUX_VAL(CP(GPMC_nWE),       (IDIS | PTD | DIS | M0)) /*GPMC_nWE*/\
806         MUX_VAL(CP(GPMC_nBE0_CLE),  (IDIS | PTD | DIS | M0)) /*GPMC_nBE0_CLE*/\
807         MUX_VAL(CP(GPMC_nBE1),      (IDIS | PTD | DIS | M4)) /*GPIO_61*/\
808         MUX_VAL(CP(GPMC_nWP),       (IEN  | PTD | DIS | M0)) /*GPMC_nWP*/\
809         MUX_VAL(CP(GPMC_WAIT0),     (IEN  | PTU | EN  | M0)) /*GPMC_WAIT0*/\
810         MUX_VAL(CP(GPMC_WAIT1),     (IEN  | PTU | EN  | M0)) /*GPMC_WAIT1*/\
811         MUX_VAL(CP(GPMC_WAIT2),     (IEN  | PTU | EN  | M4)) /*GPIO_64*/\
812         MUX_VAL(CP(GPMC_WAIT3),     (IEN  | PTU | EN  | M4)) /*GPIO_65*/\
813         MUX_VAL(CP(DSS_DATA18),     (IEN  | PTD | DIS | M4)) /*GPIO_88*/\
814         MUX_VAL(CP(DSS_DATA19),     (IEN  | PTD | DIS | M4)) /*GPIO_89*/\
815         MUX_VAL(CP(DSS_DATA20),     (IEN  | PTD | DIS | M4)) /*GPIO_90*/\
816         MUX_VAL(CP(DSS_DATA21),     (IEN  | PTD | DIS | M4)) /*GPIO_91*/\
817         MUX_VAL(CP(CAM_WEN),        (IEN  | PTD | DIS | M4)) /*GPIO_167*/\
818         MUX_VAL(CP(UART1_TX),       (IDIS | PTD | DIS | M0)) /*UART1_TX*/\
819         MUX_VAL(CP(UART1_RTS),      (IDIS | PTD | DIS | M0)) /*UART1_RTS*/\
820         MUX_VAL(CP(UART1_CTS),      (IEN | PTU | DIS | M0)) /*UART1_CTS*/\
821         MUX_VAL(CP(UART1_RX),       (IEN | PTD | DIS | M0)) /*UART1_RX*/\
822         MUX_VAL(CP(UART3_TX_IRTX),       (IDIS | PTD | DIS | M0)) /*UART3_TX*/\
823         MUX_VAL(CP(UART3_RTS_SD),      (IEN | PTD | EN | M4)) /*UART3_RTS*/\
824         MUX_VAL(CP(UART3_CTS_RCTX),      (IEN | PTU | DIS | M0)) /*UART3_CTS*/\
825         MUX_VAL(CP(UART3_RX_IRRX),       (IEN | PTD | DIS | M0)) /*UART3_RX*/\
826         /*Expansion card  */\
827         MUX_VAL(CP(MMC1_CLK),          (IEN  | PTU | EN  | M0)) /*MMC1_CLK*/\
828         MUX_VAL(CP(MMC1_CMD),          (IEN  | PTU | DIS | M0)) /*MMC1_CMD*/\
829         MUX_VAL(CP(MMC1_DAT0),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT0*/\
830         MUX_VAL(CP(MMC1_DAT1),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT1*/\
831         MUX_VAL(CP(MMC1_DAT2),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT2*/\
832         MUX_VAL(CP(MMC1_DAT3),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT3*/\
833         MUX_VAL(CP(MMC1_DAT4),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT4*/\
834         MUX_VAL(CP(MMC1_DAT5),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT5*/\
835         MUX_VAL(CP(MMC1_DAT6),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT6*/\
836         MUX_VAL(CP(MMC1_DAT7),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT7*/\
837         MUX_VAL(CP(MMC2_CLK),          (IEN  | PTU | EN  | M0)) /*MMC1_CLK*/\
838         MUX_VAL(CP(MMC2_CMD),          (IEN  | PTU | DIS | M0)) /*MMC1_CMD*/\
839         MUX_VAL(CP(MMC2_DAT0),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT0*/\
840         MUX_VAL(CP(MMC2_DAT1),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT1*/\
841         MUX_VAL(CP(MMC2_DAT2),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT2*/\
842         MUX_VAL(CP(MMC2_DAT3),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT3*/\
843         MUX_VAL(CP(MMC2_DAT4),         (IEN  | PTU | DIS | M0)) /*MMC1_DAT4*/\
844         MUX_VAL(CP(McBSP1_DX),      (IEN  | PTD | DIS | M4)) /*GPIO_158*/\
845         MUX_VAL(CP(SYS_32K),        (IEN  | PTD | DIS | M0)) /*SYS_32K*/\
846         MUX_VAL(CP(SYS_BOOT0),      (IEN  | PTD | DIS | M4)) /*GPIO_2 */\
847         MUX_VAL(CP(SYS_BOOT1),      (IEN  | PTD | DIS | M4)) /*GPIO_3 */\
848         MUX_VAL(CP(SYS_BOOT2),      (IEN  | PTD | DIS | M4)) /*GPIO_4 */\
849         MUX_VAL(CP(SYS_BOOT3),      (IEN  | PTD | DIS | M4)) /*GPIO_5 */\
850         MUX_VAL(CP(SYS_BOOT4),      (IEN  | PTD | DIS | M4)) /*GPIO_6 */\
851         MUX_VAL(CP(SYS_BOOT5),      (IEN  | PTD | DIS | M4)) /*GPIO_7 */\
852         MUX_VAL(CP(SYS_BOOT6),      (IEN  | PTD | DIS | M4)) /*GPIO_8 */\
853         MUX_VAL(CP(SYS_CLKOUT2),    (IEN  | PTU | EN  | M4)) /*GPIO_186*/\
854         MUX_VAL(CP(JTAG_nTRST),     (IEN  | PTD | DIS | M0)) /*JTAG_nTRST*/\
855         MUX_VAL(CP(JTAG_TCK),       (IEN  | PTD | DIS | M0)) /*JTAG_TCK*/\
856         MUX_VAL(CP(JTAG_TMS),       (IEN  | PTD | DIS | M0)) /*JTAG_TMS*/\
857         MUX_VAL(CP(JTAG_TDI),       (IEN  | PTD | DIS | M0)) /*JTAG_TDI*/\
858         MUX_VAL(CP(JTAG_EMU0),      (IDIS  | PTD | EN | M4)) /*JTAG_EMU0*/\
859         MUX_VAL(CP(JTAG_EMU1),      (IDIS  | PTD | EN | M4)) /*JTAG_EMU1*/\
860         MUX_VAL(CP(ETK_CLK),        (IEN  | PTD | DIS | M4)) /*GPIO_12*/\
861         MUX_VAL(CP(ETK_CTL),        (IEN  | PTD | DIS | M4)) /*GPIO_13*/\
862         MUX_VAL(CP(ETK_D0 ),        (IEN  | PTD | DIS | M4)) /*GPIO_14*/\
863         MUX_VAL(CP(ETK_D1 ),        (IEN  | PTD | DIS | M4)) /*GPIO_15*/\
864         MUX_VAL(CP(ETK_D2 ),        (IEN  | PTD | DIS | M4)) /*GPIO_16*/\
865         MUX_VAL(CP(ETK_D10),        (IEN  | PTD | DIS | M4)) /*GPIO_24*/\
866         MUX_VAL(CP(ETK_D11),        (IEN  | PTD | DIS | M4)) /*GPIO_25*/\
867         MUX_VAL(CP(ETK_D12),        (IEN  | PTD | DIS | M4)) /*GPIO_26*/\
868         MUX_VAL(CP(ETK_D13),        (IEN  | PTD | DIS | M4)) /*GPIO_27*/\
869         MUX_VAL(CP(ETK_D14),        (IEN  | PTD | DIS | M4)) /*GPIO_28*/\
870         MUX_VAL(CP(ETK_D15),        (IEN  | PTD | DIS | M4)) /*GPIO_29*/
871
872 /**********************************************************
873  * Routine: set_muxconf_regs
874  * Description: Setting up the configuration Mux registers
875  *              specific to the hardware. Many pins need
876  *              to be moved from protect to primary mode.
877  *********************************************************/
878 void set_muxconf_regs(void)
879 {
880         MUX_DEFAULT();
881 }
882
883 /**********************************************************
884  * Routine: nand+_init
885  * Description: Set up nand for nand and jffs2 commands
886  *********************************************************/
887
888 int nand_init(void)
889 {
890         /* global settings */
891         __raw_writel(0x10, GPMC_SYSCONFIG);     /* smart idle */
892         __raw_writel(0x0, GPMC_IRQENABLE);      /* isr's sources masked */
893         __raw_writel(0, GPMC_TIMEOUT_CONTROL);/* timeout disable */
894
895         /* Set the GPMC Vals . For NAND boot on 3430SDP, NAND is mapped at CS0
896          *  , NOR at CS1 and MPDB at CS3. And oneNAND boot, we map oneNAND at CS0.
897          *  We configure only GPMC CS0 with required values. Configiring other devices
898          *  at other CS in done in u-boot anyway. So we don't have to bother doing it here.
899          */
900
901 #if CONFIG_NAND_BUS_WIDTH == 16
902         __raw_writel((__raw_readl(GPMC_CONFIG1 + GPMC_CONFIG_CS0)&~0x3000)|0x1000, GPMC_CONFIG1 + GPMC_CONFIG_CS0);
903 #else
904         __raw_writel((__raw_readl(GPMC_CONFIG1 + GPMC_CONFIG_CS0)&~0x3000), GPMC_CONFIG1 + GPMC_CONFIG_CS0);
905 #endif
906
907         __raw_writel(0 , GPMC_CONFIG7 + GPMC_CONFIG_CS0);
908         delay(1000);
909
910         if ((get_mem_type() == GPMC_NAND) || (get_mem_type() == MMC_NAND)){
911                 __raw_writel( M_NAND_GPMC_CONFIG1, GPMC_CONFIG1 + GPMC_CONFIG_CS0);
912                 __raw_writel( M_NAND_GPMC_CONFIG2, GPMC_CONFIG2 + GPMC_CONFIG_CS0);
913                 __raw_writel( M_NAND_GPMC_CONFIG3, GPMC_CONFIG3 + GPMC_CONFIG_CS0);
914                 __raw_writel( M_NAND_GPMC_CONFIG4, GPMC_CONFIG4 + GPMC_CONFIG_CS0);
915                 __raw_writel( M_NAND_GPMC_CONFIG5, GPMC_CONFIG5 + GPMC_CONFIG_CS0);
916                 __raw_writel( M_NAND_GPMC_CONFIG6, GPMC_CONFIG6 + GPMC_CONFIG_CS0);
917
918                 /* Enable the GPMC Mapping */
919                 __raw_writel(( ((OMAP34XX_GPMC_CS0_SIZE & 0xF)<<8) |
920                              ((NAND_BASE_ADR>>24) & 0x3F) |
921                              (1<<6) ),  (GPMC_CONFIG7 + GPMC_CONFIG_CS0));
922                 delay(2000);
923
924                 if (nand_chip()){
925 #ifdef CFG_PRINTF
926                         printf("Unsupported Chip!\n");
927 #endif
928 #ifdef CONFIG_MMC
929                         return 0;
930 #else
931                         return 1;
932 #endif
933                 }
934
935         }
936 /* One NAND disabled for now */
937 #if 0
938         if ((get_mem_type() == GPMC_ONENAND) || (get_mem_type() == MMC_ONENAND)){
939                 __raw_writel( ONENAND_GPMC_CONFIG1, GPMC_CONFIG1 + GPMC_CONFIG_CS0);
940                 __raw_writel( ONENAND_GPMC_CONFIG2, GPMC_CONFIG2 + GPMC_CONFIG_CS0);
941                 __raw_writel( ONENAND_GPMC_CONFIG3, GPMC_CONFIG3 + GPMC_CONFIG_CS0);
942                 __raw_writel( ONENAND_GPMC_CONFIG4, GPMC_CONFIG4 + GPMC_CONFIG_CS0);
943                 __raw_writel( ONENAND_GPMC_CONFIG5, GPMC_CONFIG5 + GPMC_CONFIG_CS0);
944                 __raw_writel( ONENAND_GPMC_CONFIG6, GPMC_CONFIG6 + GPMC_CONFIG_CS0);
945
946                 /* Enable the GPMC Mapping */
947                 __raw_writel(( ((OMAP34XX_GPMC_CS0_SIZE & 0xF)<<8) |
948                              ((ONENAND_BASE>>24) & 0x3F) |
949                              (1<<6) ),  (GPMC_CONFIG7 + GPMC_CONFIG_CS0));
950                 delay(2000);
951
952                 if (onenand_chip()){
953 #ifdef CFG_PRINTF
954                         printf("OneNAND Unsupported !\n");
955 #endif
956                         return 1;
957                 }
958         }
959 #endif
960         return 0;
961 }
962
963 typedef int (mmc_boot_addr) (void);
964 int mmc_boot(unsigned char *buf)
965 {
966
967        long size = 0;
968 #ifdef CFG_CMD_FAT
969        block_dev_desc_t *dev_desc = NULL;
970        unsigned char ret = 0;
971
972        printf("Starting X-loader on MMC \n");
973
974        ret = mmc_init(1);
975        if(ret == 0){
976                printf("\n MMC init failed \n");
977                return 0;
978        }
979
980        dev_desc = mmc_get_dev(0);
981        fat_register_device(dev_desc, 1);
982        size = file_fat_read("u-boot.bin", buf, 0);
983        if (size == -1) {
984                return 0;
985        }
986        printf("\n%ld Bytes Read from MMC \n", size);
987
988        printf("Starting OS Bootloader from MMC...\n");
989 #endif
990
991        return size;
992 }
993
994 /* optionally do something like blinking LED */
995 void board_hang(void)
996 { while (1); }
997
998 /******************************************************************************
999  * Dummy function to handle errors for EABI incompatibility
1000  *****************************************************************************/
1001 void raise(void)
1002 {
1003 }
1004
1005 /******************************************************************************
1006  * Dummy function to handle errors for EABI incompatibility
1007  *****************************************************************************/
1008 void abort(void)
1009 {
1010 }