LG Optimus Black (P970) support
[x-loader-sniper.git] / board / sniper / sniper.c
1 /*
2  * (C) Copyright 2006
3  * Texas Instruments, <www.ti.com>
4  * Jian Zhang <jzhang@ti.com>
5  * Richard Woodruff <r-woodruff2@ti.com>
6  * (C) Copyright 2008-2010 LGE Inc. from omap3430labrador.c
7  * (C) Copyright 2014 Paul Kocialkowski <contact@paulk.fr>
8  *
9  * See file CREDITS for list of people who contributed to this
10  * project.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License as
14  * published by the Free Software Foundation; either version 2 of
15  * the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
25  * MA 02111-1307 USA
26  */
27
28 #include <common.h>
29 #include <command.h>
30 #include <part.h>
31 #include <fat.h>
32 #include <asm/arch/cpu.h>
33 #include <asm/arch/bits.h>
34 #include <asm/arch/mux.h>
35 #include <asm/arch/gpio.h>
36 #include <asm/arch/sys_proto.h>
37 #include <asm/arch/sys_info.h>
38 #include <asm/arch/clocks.h>
39 #include <asm/arch/mem.h>
40
41 /* Used to index into DPLL parameter tables */
42 struct dpll_param {
43         unsigned int m;
44         unsigned int n;
45         unsigned int fsel;
46         unsigned int m2;
47 };
48
49 typedef struct dpll_param dpll_param;
50
51 struct dpll_per_param {
52         unsigned int sys_clk;
53         unsigned int m;
54         unsigned int n;
55         unsigned int clkin;
56         unsigned int sd;
57         unsigned int dco;
58         unsigned int m2;
59         unsigned int m3;
60         unsigned int m4;
61         unsigned int m5;
62         unsigned int m6;
63         unsigned int m2div;
64 };
65
66 typedef struct dpll_per_param dpll_per_param;
67
68 /* Following functions are exported from lowlevel_init.S */
69 extern dpll_param *get_mpu_dpll_param();
70 extern dpll_param *get_iva_dpll_param();
71 extern dpll_param *get_core_dpll_param();
72 extern dpll_per_param *get_per_dpll_param();
73
74 #define __raw_readl(a)          (*(volatile unsigned int *)(a))
75 #define __raw_writel(v, a)      (*(volatile unsigned int *)(a) = (v))
76 #define __raw_readw(a)          (*(volatile unsigned short *)(a))
77 #define __raw_writew(v, a)      (*(volatile unsigned short *)(a) = (v))
78
79 /*******************************************************
80  * Routine: delay
81  * Description: spinning delay to use before udelay works
82  ******************************************************/
83 static inline void delay(unsigned long loops)
84 {
85         __asm__ volatile ("1:\n" "subs %0, %1, #1\n"
86                           "bne 1b":"=r" (loops):"0"(loops));
87 }
88
89 void udelay (unsigned long usecs) {
90         delay(usecs);
91 }
92
93 /*****************************************
94  * Routine: board_init
95  * Description: Early hardware init.
96  *****************************************/
97 int board_init(void)
98 {
99         return 0;
100 }
101
102 /*************************************************************
103  * Routine: get_mem_type(void) - returns the kind of memory connected
104  * to GPMC that we are trying to boot form. Uses SYS BOOT settings.
105  *************************************************************/
106 u32 get_mem_type(void)
107 {
108         return GPMC_NONE;
109 }
110
111 #ifdef CFG_SNIPER_DDR
112 /*********************************************************************
113  * config_sniper_ddr() - Init DDR
114  *********************************************************************/
115 void config_sniper_ddr(void)
116 {
117         /* check if its h/w or s/w reset for warm reset workaround */
118         if (__raw_readl(PRM_RSTTST) & 0x2) {
119                 /* Enable SDRC clock & wait SDRC idle status to access*/
120                 sr32(CM_ICLKEN1_CORE, 1, 1, 0x1);
121                 wait_on_value(BIT1, 0, CM_IDLEST1_CORE, LDELAY);
122         }
123         else {
124                 /* do a SDRC reset between types to clear regs */
125                 __raw_writel(SOFTRESET, SDRC_SYSCONFIG);/* reset sdrc */
126                 /* wait on reset */
127                 wait_on_value(BIT0, BIT0, SDRC_STATUS, 12000000);
128                 __raw_writel(0, SDRC_SYSCONFIG);/* clear soft reset */
129         }
130         /* Clear reset sources */
131         __raw_writel(0xfff, PRM_RSTTST);
132
133         /* setup sdrc to ball mux */
134         __raw_writel(SDP_SDRC_SHARING, SDRC_SHARING);
135
136         /* Configure the first chip select */
137         /* set mdcfg */
138         __raw_writel(SDP_SDRC_MDCFG_0_DDR, SDRC_MCFG_0);                /* CS0 */
139         __raw_writel(SDP_SDRC_MDCFG_0_DDR, SDRC_MCFG_1);                /* CS1 */
140
141         /* 2 * 128M = 256M for cs1 */
142         __raw_writel(0x2, SDRC_CS_CFG);
143
144         /* set timing */
145         __raw_writel(SNIPER_SDRC_ACTIM_CTRLA_0, SDRC_ACTIM_CTRLA_0);    /* CS0 */
146         __raw_writel(SNIPER_SDRC_ACTIM_CTRLB_0, SDRC_ACTIM_CTRLB_0);    /* CS0 */
147         __raw_writel(SDP_SDRC_RFR_CTRL, SDRC_RFR_CTRL_0);
148
149         __raw_writel(SNIPER_SDRC_ACTIM_CTRLA_0, SDRC_ACTIM_CTRLA_1);    /* CS1 */
150         __raw_writel(SNIPER_SDRC_ACTIM_CTRLB_0, SDRC_ACTIM_CTRLB_1);    /* CS1 */
151         __raw_writel(SDP_SDRC_RFR_CTRL, SDRC_RFR_CTRL_1);
152
153         /* init sequence for mDDR/mSDR using manual commands (DDR is different) */
154         __raw_writel(CMD_NOP, SDRC_MANUAL_0);
155         delay(5000);
156         __raw_writel(CMD_PRECHARGE, SDRC_MANUAL_0);
157         __raw_writel(CMD_AUTOREFRESH, SDRC_MANUAL_0);
158         __raw_writel(CMD_AUTOREFRESH, SDRC_MANUAL_0);
159
160         /* set mr0 */
161         __raw_writel(SDP_SDRC_MR_0_DDR, SDRC_MR_0);
162
163         /* drive strength weak */
164         __raw_writel(0x20, 0x6D00008C); //SDRC_EMR2_0
165
166         /* init sequence for mDDR/mSDR using manual commands (DDR is different) */
167         __raw_writel(CMD_NOP, SDRC_MANUAL_1);
168         delay(5000);
169         __raw_writel(CMD_PRECHARGE, SDRC_MANUAL_1);
170         __raw_writel(CMD_AUTOREFRESH, SDRC_MANUAL_1);
171         __raw_writel(CMD_AUTOREFRESH, SDRC_MANUAL_1);
172
173         /* set mr0 */
174         __raw_writel(SDP_SDRC_MR_0_DDR, SDRC_MR_1);
175
176         /* drive strength weak */
177         __raw_writel(0x20, 0x6D0000BC); //SDRC_EMR2_1
178
179         __raw_writel(0x2, SDRC_CS_CFG);
180
181         /* set up dllB-CS1 */
182         __raw_writel(SDP_SDRC_DLLAB_CTRL, SDRC_DLLB_CTRL);
183         delay(0x2000);  /* give time to lock */
184
185         /* set up dllA-CS0 */
186         __raw_writel(SDP_SDRC_DLLAB_CTRL, SDRC_DLLA_CTRL);
187         delay(0x2000);  /* give time to lock */
188 }
189 #endif // CFG_SNIPER_DDR
190
191 /*************************************************************
192  * get_sys_clk_speed - determine reference oscillator speed
193  *  based on known 32kHz clock and gptimer.
194  *************************************************************/
195 u32 get_osc_clk_speed(void)
196 {
197         u32 start, cstart, cend, cdiff, cdiv, val;
198
199         val = __raw_readl(PRM_CLKSRC_CTRL);
200
201         if (val & SYSCLKDIV_2)
202                 cdiv = 2;
203         else
204                 cdiv = 1;
205
206         /* enable timer2 */
207         val = __raw_readl(CM_CLKSEL_WKUP) | BIT0;
208         __raw_writel(val, CM_CLKSEL_WKUP);      /* select sys_clk for GPT1 */
209
210         /* Enable I and F Clocks for GPT1 */
211         val = __raw_readl(CM_ICLKEN_WKUP) | BIT0 | BIT2;
212         __raw_writel(val, CM_ICLKEN_WKUP);
213         val = __raw_readl(CM_FCLKEN_WKUP) | BIT0;
214         __raw_writel(val, CM_FCLKEN_WKUP);
215
216         __raw_writel(0, OMAP34XX_GPT1 + TLDR);          /* start counting at 0 */
217         __raw_writel(GPT_EN, OMAP34XX_GPT1 + TCLR);     /* enable clock */
218         /* enable 32kHz source */
219         /* enabled out of reset */
220         /* determine sys_clk via gauging */
221
222         start = 20 + __raw_readl(S32K_CR);      /* start time in 20 cycles */
223         while (__raw_readl(S32K_CR) < start) ;  /* dead loop till start time */
224         cstart = __raw_readl(OMAP34XX_GPT1 + TCRR);     /* get start sys_clk count */
225         while (__raw_readl(S32K_CR) < (start + 20)) ;   /* wait for 40 cycles */
226         cend = __raw_readl(OMAP34XX_GPT1 + TCRR);       /* get end sys_clk count */
227         cdiff = cend - cstart;  /* get elapsed ticks */
228         cdiff *= cdiv;
229
230         /* based on number of ticks assign speed */
231         if (cdiff > 19000)
232                 return S38_4M;
233         else if (cdiff > 15200)
234                 return S26M;
235         else if (cdiff > 13000)
236                 return S24M;
237         else if (cdiff > 9000)
238                 return S19_2M;
239         else if (cdiff > 7600)
240                 return S13M;
241         else
242                 return S12M;
243 }
244
245 /******************************************************************************
246  * prcm_init() - inits clocks for PRCM as defined in clocks.h
247  *   -- called from SRAM, or Flash (using temp SRAM stack).
248  *****************************************************************************/
249 void prcm_init(void)
250 {
251         u32 osc_clk = 0, sys_clkin_sel;
252         dpll_per_param *dpll_per_param_p;
253         dpll_param *dpll_param_p;
254         u32 clk_index, sil_index;
255
256         /* Gauge the input clock speed and find out the sys_clkin_sel
257          * value corresponding to the input clock.
258          */
259         osc_clk = get_osc_clk_speed();
260         get_sys_clkin_sel(osc_clk, &sys_clkin_sel);
261
262         sr32(PRM_CLKSEL, 0, 3, sys_clkin_sel);  /* set input crystal speed */
263
264         /* If the input clock is greater than 19.2M always divide/2 */
265         sr32(PRM_CLKSRC_CTRL, 6, 2, 1); /* input clock divider */
266         clk_index = sys_clkin_sel;
267
268         sr32(PRM_CLKSRC_CTRL, 0, 2, 0);/* Bypass mode: T2 inputs a square clock */
269
270         /* The DPLL tables are defined according to sysclk value and
271          * silicon revision. The clk_index value will be used to get
272          * the values for that input sysclk from the DPLL param table
273          * and sil_index will get the values for that SysClk for the
274          * appropriate silicon rev.
275          */
276         sil_index = !(get_cpu_rev() == CPU_3XX_ES10);
277
278         /* Unlock MPU DPLL (slows things down, and needed later) */
279         sr32(CM_CLKEN_PLL_MPU, 0, 3, PLL_LOW_POWER_BYPASS);
280         wait_on_value(BIT0, 0, CM_IDLEST_PLL_MPU, LDELAY);
281
282         /* Getting the base address of Core DPLL param table */
283         dpll_param_p = (dpll_param *) get_core_dpll_param();
284         /* Moving it to the right sysclk and ES rev base */
285         dpll_param_p = dpll_param_p + 1 * clk_index + sil_index;
286         /* CORE DPLL */
287         /* sr32(CM_CLKSEL2_EMU) set override to work when asleep */
288         sr32(CM_CLKEN_PLL, 0, 3, PLL_FAST_RELOCK_BYPASS);
289         wait_on_value(BIT0, 0, CM_IDLEST_CKGEN, LDELAY);
290
291          /* For 3430 ES1.0 Errata 1.50, default value directly doesnt
292         work. write another value and then default value. */
293         sr32(CM_CLKSEL1_EMU, 16, 5, CORE_M3X2 + 1);     /* m3x2 */
294         sr32(CM_CLKSEL1_EMU, 16, 5, CORE_M3X2); /* m3x2 */
295         sr32(CM_CLKSEL1_PLL, 27, 2, dpll_param_p->m2);  /* Set M2 */
296         sr32(CM_CLKSEL1_PLL, 16, 11, dpll_param_p->m);  /* Set M */
297         sr32(CM_CLKSEL1_PLL, 8, 7, dpll_param_p->n);    /* Set N */
298         sr32(CM_CLKSEL1_PLL, 6, 1, 0);  /* 96M Src */
299         sr32(CM_CLKSEL_CORE, 8, 4, CORE_SSI_DIV);       /* ssi */
300         sr32(CM_CLKSEL_CORE, 4, 2, CORE_FUSB_DIV);      /* fsusb */
301         sr32(CM_CLKSEL_CORE, 2, 2, CORE_L4_DIV);        /* l4 */
302         sr32(CM_CLKSEL_CORE, 0, 2, CORE_L3_DIV);        /* l3 */
303         sr32(CM_CLKSEL_GFX, 0, 3, GFX_DIV);     /* gfx */
304         sr32(CM_CLKSEL_WKUP, 1, 2, WKUP_RSM);   /* reset mgr */
305         sr32(CM_CLKEN_PLL, 4, 4, dpll_param_p->fsel);   /* FREQSEL */
306         sr32(CM_CLKEN_PLL, 0, 3, PLL_LOCK);     /* lock mode */
307         wait_on_value(BIT0, 1, CM_IDLEST_CKGEN, LDELAY);
308
309         /* Getting the base address to PER  DPLL param table */
310         dpll_per_param_p = (dpll_per_param *) get_per_dpll_param();
311         /* Moving it to the right sysclk base */
312         dpll_per_param_p = dpll_per_param_p + clk_index;
313         /* PER DPLL */
314         sr32(CM_CLKEN_PLL, 16, 3, PLL_STOP);
315         wait_on_value(BIT1, 0, CM_IDLEST_CKGEN, LDELAY);
316
317         sr32(CM_CLKSEL2_PLL,  8, 12, dpll_per_param_p->m);
318         sr32(CM_CLKSEL2_PLL,  0, 7, dpll_per_param_p->n);
319         sr32(PRM_CLKSRC_CTRL, 8, 1, dpll_per_param_p->clkin);
320         sr32(CM_CLKSEL2_PLL, 24, 7, dpll_per_param_p->sd);
321         sr32(CM_CLKSEL2_PLL, 21, 3, dpll_per_param_p->dco);
322         sr32(CM_CLKSEL3_PLL,  0, 5, dpll_per_param_p->m2);
323         sr32(CM_CLKSEL_DSS,   8, 6, dpll_per_param_p->m3);
324         sr32(CM_CLKSEL_DSS,   0, 6, dpll_per_param_p->m4);
325         sr32(CM_CLKSEL_CAM,   0, 6, dpll_per_param_p->m5);
326         sr32(CM_CLKSEL1_EMU, 24, 6, dpll_per_param_p->m6);
327         sr32(CM_CLKSEL_CORE, 12, 2, dpll_per_param_p->m2div);
328
329         sr32(CM_CLKEN_PLL, 16, 3, PLL_LOCK);    /* lock mode */
330         wait_on_value(BIT1, 2, CM_IDLEST_CKGEN, LDELAY);
331
332         /* Getting the base address to MPU DPLL param table */
333         dpll_param_p = (dpll_param *) get_mpu_dpll_param();
334
335         /* Moving it to the right sysclk and ES rev base */
336         dpll_param_p = dpll_param_p + 1 * clk_index + sil_index;
337
338         /* MPU DPLL (unlocked already) */
339         sr32(CM_CLKSEL1_PLL_MPU, 8, 11, dpll_param_p->m);       /* Set M */
340         sr32(CM_CLKSEL1_PLL_MPU, 0, 7, dpll_param_p->n);        /* Set N */
341         sr32(CM_CLKSEL2_PLL_MPU, 0, 5, dpll_param_p->m2);       /* Set M2 */
342
343         sr32(CM_CLKEN_PLL_MPU, 0, 3, PLL_LOCK); /* lock mode */
344         wait_on_value(BIT0, 1, CM_IDLEST_PLL_MPU, LDELAY);
345
346         /* Set up GPTimers to sys_clk source only */
347         sr32(CM_CLKSEL_PER, 0, 8, 0xff);
348         sr32(CM_CLKSEL_WKUP, 0, 1, 1);
349
350         delay(5000);
351 }
352
353 /**********************************************************
354  * Routine: s_init
355  * Description: Does early system init of muxing and clocks.
356  * - Called at time when only stack is available.
357  **********************************************************/
358
359 void s_init(void)
360 {
361         watchdog_init();
362         try_unlock_memory();
363         set_muxconf_regs();
364         delay(100);
365         per_clocks_enable();
366         prcm_init();
367         config_sniper_ddr();
368 }
369
370 /*******************************************************
371  * Routine: misc_init_r
372  * Description: Init ethernet (done here so udelay works)
373  ********************************************************/
374 int misc_init_r(void)
375 {
376         unsigned char data;
377
378         /* In order to boot from MMC1 (microsd card), the LP870 3.0V_MMC
379          * regulator has to be enabled. The LP870 is accessed through I2C3.
380          *
381          * Enabling 3.0V_MOTION and 1.8V_MOTION_VIO is required to power the
382          * sensors that are slaves on I2C3. When not powered, these sensors
383          * cause I2C3 SCK to stay low. */
384
385         i2c_set_bus_num(0);
386
387         /* TWL4030 VAUX2: 3.0V_MOTION */
388
389         data = 0x20;
390         i2c_write(0x4b, 0x76, 1, &data, 1);
391         data = 0x9;
392         i2c_write(0x4b, 0x79, 1, &data, 1);
393
394         /* TWL4030 VDAC: 1.8V_MOTION_VIO */
395
396         data = 0x20;
397         i2c_write(0x4b, 0x96, 1, &data, 1);
398         data = 0x2;
399         i2c_write(0x4b, 0x99, 1, &data, 1);
400
401         /* LP870 CAM_SUBPM_EN */
402
403         omap_request_gpio(37);
404         omap_set_gpio_direction(37, 0);
405         omap_set_gpio_dataout(37, 1);
406
407         i2c_set_bus_num(2);
408
409         /* LP870 LDO1: 3.0V_MMC */
410
411         data = 0x1d;
412         i2c_write(0x7d, 0x1, 1, &data, 1);
413         data = 0x1;
414         i2c_write(0x7d, 0x8, 1, &data, 1);
415
416         i2c_set_bus_num(0);
417
418         /* TWL4030 VMMC2: 1.8V_MMC_EN */
419
420         data = 0x20;
421         i2c_write(0x4B, 0x86, 1, &data, 1);
422         data = 0xB;
423         i2c_write(0x4B, 0x89, 1, &data, 1);
424
425         return 0;
426 }
427
428 /******************************************************
429  * Routine: wait_for_command_complete
430  * Description: Wait for posting to finish on watchdog
431  ******************************************************/
432 void wait_for_command_complete(unsigned int wd_base)
433 {
434         int pending = 1;
435         do {
436                 pending = __raw_readl(wd_base + WWPS);
437         } while (pending);
438 }
439
440 /****************************************
441  * Routine: watchdog_init
442  * Description: Shut down watch dogs
443  *****************************************/
444 void watchdog_init(void)
445 {
446         /* There are 3 watch dogs WD1=Secure, WD2=MPU, WD3=IVA. WD1 is
447          * either taken care of by ROM (HS/EMU) or not accessible (GP).
448          * We need to take care of WD2-MPU or take a PRCM reset.  WD3
449          * should not be running and does not generate a PRCM reset.
450          */
451         sr32(CM_FCLKEN_WKUP, 5, 1, 1);
452         sr32(CM_ICLKEN_WKUP, 5, 1, 1);
453         wait_on_value(BIT5, 0x20, CM_IDLEST_WKUP, 5);   /* some issue here */
454
455         __raw_writel(WD_UNLOCK1, WD2_BASE + WSPR);
456         wait_for_command_complete(WD2_BASE);
457         __raw_writel(WD_UNLOCK2, WD2_BASE + WSPR);
458 }
459
460 /**********************************************
461  * Routine: dram_init
462  * Description: sets uboots idea of sdram size
463  **********************************************/
464 int dram_init(void)
465 {
466         return 0;
467 }
468
469 /*****************************************************************
470  * Routine: peripheral_enable
471  * Description: Enable the clks & power for perifs (GPT2, UART1,...)
472  ******************************************************************/
473 void per_clocks_enable(void)
474 {
475         /* Enable GP2 timer. */
476         sr32(CM_CLKSEL_PER, 0, 1, 0x1); /* GPT2 = sys clk */
477         sr32(CM_ICLKEN_PER, 3, 1, 0x1); /* ICKen GPT2 */
478         sr32(CM_FCLKEN_PER, 3, 1, 0x1); /* FCKen GPT2 */
479
480 #ifdef CFG_NS16550
481         /* UART 3 Clocks */
482         sr32(CM_FCLKEN_PER, 11, 1, 0x1);
483         sr32(CM_ICLKEN_PER, 11, 1, 0x1);
484
485 #endif
486
487 #ifdef CONFIG_DRIVER_OMAP34XX_I2C
488         /* I2C clocks */
489         sr32(CM_FCLKEN1_CORE, 15, 3, 0x7);
490         sr32(CM_ICLKEN1_CORE, 15, 3, 0x7);      /* I2C1,2,3 = on */
491 #endif
492
493         /* Enable the ICLK for 32K Sync Timer as its used in udelay */
494         sr32(CM_ICLKEN_WKUP, 2, 1, 0x1);
495
496         /* GPIO1 clocks */
497         sr32(CM_FCLKEN_PER, 13, 1, 0x1);
498         sr32(CM_ICLKEN_PER, 13, 1, 0x1);
499
500         /* MMC1 clocks */
501         sr32(CM_FCLKEN1_CORE, 24, 1, 0x1);
502         sr32(CM_ICLKEN1_CORE, 24, 1, 0x1);
503
504         /* MMC2 clocks */
505         sr32(CM_FCLKEN1_CORE, 25, 1, 0x1);
506         sr32(CM_ICLKEN1_CORE, 25, 1, 0x1);
507
508         delay(1000);
509 }
510
511 #define         MUX_VAL(OFFSET,VALUE)\
512                 __raw_writew((VALUE), OMAP34XX_CTRL_BASE + (OFFSET));
513
514 #define         CP(x)   (CONTROL_PADCONF_##x)
515 /*
516  * IEN  - Input Enable
517  * IDIS - Input Disable
518  * PTD  - Pull type Down
519  * PTU  - Pull type Up
520  * DIS  - Pull type selection is inactive
521  * EN   - Pull type selection is active
522  * M0   - Mode 0
523  * The commented string gives the final mux configuration for that pin
524  */
525
526 #define MUX_SNIPER()\
527         MUX_VAL(CP(GPMC_A4),        (IDIS | PTU | DIS | M4)) /* GPIO_37: CAM_SUBPM_EN */\
528         MUX_VAL(CP(MMC1_CLK),       (IEN  | PTU | EN  | M0)) /* MMC1_CLK */\
529         MUX_VAL(CP(MMC1_CMD),       (IEN  | PTU | EN  | M0)) /* MMC1_CMD */\
530         MUX_VAL(CP(MMC1_DAT0),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT0 */\
531         MUX_VAL(CP(MMC1_DAT1),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT1 */\
532         MUX_VAL(CP(MMC1_DAT2),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT2 */\
533         MUX_VAL(CP(MMC1_DAT3),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT3 */\
534         MUX_VAL(CP(MMC1_DAT4),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT4 */\
535         MUX_VAL(CP(MMC1_DAT5),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT5 */\
536         MUX_VAL(CP(MMC1_DAT6),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT6 */\
537         MUX_VAL(CP(MMC1_DAT7),      (IEN  | PTU | EN  | M0)) /* MMC1_DAT7 */\
538         MUX_VAL(CP(MMC2_CLK),       (IEN  | PTU | EN  | M0)) /* MMC2_CLK */\
539         MUX_VAL(CP(MMC2_CMD),       (IEN  | PTU | EN  | M0)) /* MMC2_CMD */\
540         MUX_VAL(CP(MMC2_DAT0),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT0 */\
541         MUX_VAL(CP(MMC2_DAT1),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT1 */\
542         MUX_VAL(CP(MMC2_DAT2),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT2 */\
543         MUX_VAL(CP(MMC2_DAT3),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT3 */\
544         MUX_VAL(CP(MMC2_DAT4),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT4 */\
545         MUX_VAL(CP(MMC2_DAT5),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT5 */\
546         MUX_VAL(CP(MMC2_DAT6),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT6 */\
547         MUX_VAL(CP(MMC2_DAT7),      (IEN  | PTU | EN  | M0)) /* MMC2_DAT7 */\
548         MUX_VAL(CP(UART3_CTS_RCTX), (IEN  | PTD | EN  | M0)) /* UART3_CTS_RCTX */\
549         MUX_VAL(CP(UART3_RTS_SD),   (IDIS | PTD | DIS | M0)) /* UART3_RTS_SD */\
550         MUX_VAL(CP(UART3_RX_IRRX),  (IEN  | PTD | DIS | M0)) /* UART3_RX_IRRX */\
551         MUX_VAL(CP(UART3_TX_IRTX),  (IDIS | PTD | DIS | M0)) /* UART3_TX_IRTX */\
552         MUX_VAL(CP(I2C1_SCL),       (IEN  | PTU | EN  | M0)) /* I2C1_SCL */\
553         MUX_VAL(CP(I2C1_SDA),       (IEN  | PTU | EN  | M0)) /* I2C1_SDA */\
554         MUX_VAL(CP(I2C3_SCL),       (IEN  | PTU | DIS | M0)) /* I2C3_SCL */\
555         MUX_VAL(CP(I2C3_SDA),       (IEN  | PTU | DIS | M0)) /* I2C3_SDA */
556
557 /**********************************************************
558  * Routine: set_muxconf_regs
559  * Description: Setting up the configuration Mux registers
560  *              specific to the hardware. Many pins need
561  *              to be moved from protect to primary mode.
562  *********************************************************/
563 void set_muxconf_regs(void)
564 {
565         MUX_SNIPER();
566 }
567
568 /**********************************************************
569  * Routine: nand+_init
570  * Description: Set up nand for nand and jffs2 commands
571  *********************************************************/
572
573 int nand_init(void)
574 {
575         return 0;
576 }
577
578 /* optionally do something like blinking LED */
579 void board_hang(void)
580 {
581         return;
582 }
583
584 /******************************************************************************
585  * Dummy function to handle errors for EABI incompatibility
586  *****************************************************************************/
587 void raise(void)
588 {
589 }
590
591 /******************************************************************************
592  * Dummy function to handle errors for EABI incompatibility
593  *****************************************************************************/
594 void abort(void)
595 {
596 }