packages/hal/arm/mx27/3stack/v2_0/src/board_misc.c

   1 //==========================================================================
   2 //
   3 //      board_misc.c
   4 //
   5 //      HAL misc board support code for the board
   6 //
   7 //==========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  12 //
  13 // eCos is free software; you can redistribute it and/or modify it under
  14 // the terms of the GNU General Public License as published by the Free
  15 // Software Foundation; either version 2 or (at your option) any later version.
  16 //
  17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 // for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License along
  23 // with eCos; if not, write to the Free Software Foundation, Inc.,
  24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 //
  26 // As a special exception, if other files instantiate templates or use macros
  27 // or inline functions from this file, or you compile this file and link it
  28 // with other works to produce a work based on this file, this file does not
  29 // by itself cause the resulting work to be covered by the GNU General Public
  30 // License. However the source code for this file must still be made available
  31 // in accordance with section (3) of the GNU General Public License.
  32 //
  33 // This exception does not invalidate any other reasons why a work based on
  34 // this file might be covered by the GNU General Public License.
  35 //
  36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  37 // at http://sources.redhat.com/ecos/ecos-license/
  38 // -------------------------------------------
  39 //####ECOSGPLCOPYRIGHTEND####
  40 //========================================================================*/
  41
  42 #include <redboot.h>
  43 #include <pkgconf/hal.h>
  44 #include <pkgconf/system.h>
  45 #include CYGBLD_HAL_PLATFORM_H
  46
  47 #include <cyg/infra/cyg_type.h>         // base types
  48 #include <cyg/infra/cyg_trac.h>         // tracing macros
  49 #include <cyg/infra/cyg_ass.h>          // assertion macros
  50
  51 #include <cyg/hal/hal_io.h>             // IO macros
  52 #include <cyg/hal/hal_arch.h>           // Register state info
  53 #include <cyg/hal/hal_diag.h>
  54 #include <cyg/hal/hal_intr.h>           // Interrupt names
  55 #include <cyg/hal/hal_cache.h>
  56 #include <cyg/hal/hal_soc.h>            // Hardware definitions
  57 #include <cyg/hal/fsl_board.h>          // Platform specifics
  58
  59 #include <cyg/infra/diag.h>             // diag_printf
  60
  61 // All the MM table layout is here:
  62 #include <cyg/hal/hal_mm.h>
  63 #include <cyg/io/mxc_spi.h>
  64
  65 externC void* memset(void *, int, size_t);
  66
  67 void hal_mmu_init(void)
  68 {
  69     unsigned long ttb_base = RAM_BANK0_BASE + 0x4000;
  70     unsigned long i;
  71
  72     /*
  73      * Set the TTB register
  74      */
  75     asm volatile ("mcr  p15,0,%0,c2,c0,0" : : "r"(ttb_base) /*:*/);
  76
  77     /*
  78      * Set the Domain Access Control Register
  79      */
  80     i = ARM_ACCESS_DACR_DEFAULT;
  81     asm volatile ("mcr  p15,0,%0,c3,c0,0" : : "r"(i) /*:*/);
  82
  83     /*
  84      * First clear all TT entries - ie Set them to Faulting
  85      */
  86     memset((void *)ttb_base, 0, ARM_FIRST_LEVEL_PAGE_TABLE_SIZE);
  87
  88     /*             Actual    Virtual  Size   Attributes                                                    Function  */
  89     /*             Base      Base     MB      cached?           buffered?        access permissions                 */
  90     /*             xxx00000  xxx00000                                                                                */
  91     X_ARM_MMU_SECTION(0x000, 0xF00,   0x001, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* Boot Rom */
  92     X_ARM_MMU_SECTION(0x100, 0x100,   0x001, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* Internal Regsisters */
  93     X_ARM_MMU_SECTION(0x800, 0x800,   0x001, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* CSI/ATA Regsisters */
  94     X_ARM_MMU_SECTION(0xA00, 0x000,   0x080, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
  95     X_ARM_MMU_SECTION(0xA00, 0xA00,   0x080, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* SDRAM */
  96     X_ARM_MMU_SECTION(0xA00, 0xA80,   0x080, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* SDRAM */
  97     X_ARM_MMU_SECTION(0xC00, 0xC00,   0x020, ARM_CACHEABLE,   ARM_BUFFERABLE,   ARM_ACCESS_PERM_RW_RW); /* Flash */
  98     X_ARM_MMU_SECTION(0xD60, 0xD60,   0x020, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* CS5 for External I/0 */
  99     X_ARM_MMU_SECTION(0xD80, 0xD80,   0x100, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* EMI control/PCMCIA */
 100     X_ARM_MMU_SECTION(0xFFF, 0xFFF,   0x001, ARM_UNCACHEABLE, ARM_UNBUFFERABLE, ARM_ACCESS_PERM_RW_RW); /* VRAM */
 101 }
 102
 103 //
 104 // Platform specific initialization
 105 //
 106 static void fec_gpio_init(void)
 107 {
 108         unsigned long addr , val;
 109
 110         /* PF23 PF10*/
 111         addr = SOC_GPIOF_BASE;
 112         /* OCR2: AIN=0x00 */
 113         HAL_READ_UINT32(addr+GPIO_OCR2, val);
 114         val = val & (~(0x00000003<<(13)));
 115         HAL_WRITE_UINT32(addr+GPIO_OCR2, val);
 116
 117          /* OCR1: DR */
 118         HAL_READ_UINT32(addr+GPIO_OCR1, val);
 119         val = val | ((0x00000003<<(20)));
 120         HAL_WRITE_UINT32(addr+GPIO_OCR1, val);
 121
 122         /* DDR: OUTPUT */
 123         HAL_READ_UINT32(addr+GPIO_DDIR, val);
 124         val = val | (0x00000001<<(23)) | (1<<10);
 125         HAL_WRITE_UINT32(addr+GPIO_DDIR, val);
 126
 127         /* GIUS: GPIO */
 128         HAL_READ_UINT32(addr+GPIO_GIUS, val);
 129         val = val | (0x00000001<<23) | (1<<10);
 130         HAL_WRITE_UINT32(addr+GPIO_GIUS, val);
 131
 132         /* DR: DATA */
 133         HAL_READ_UINT32(addr+GPIO_DR, val);
 134         val = val & (~(1<<10));
 135         HAL_WRITE_UINT32(addr+GPIO_DR, val);
 136
 137
 138         /* PD16-0*/
 139         addr = SOC_GPIOD_BASE;
 140         /* PD16 OCR2: AIN=0x00 */
 141         HAL_READ_UINT32(addr+GPIO_OCR2, val);
 142         val = val & ~0x00000003;
 143         HAL_WRITE_UINT32(addr+GPIO_OCR2, val);
 144
 145         /* PD9, 3-0  OCR1: AIN=0x00 */
 146         HAL_READ_UINT32(addr+GPIO_OCR1, val);
 147         val = val & ~(0x000C00FF);
 148         HAL_WRITE_UINT32(addr+GPIO_OCR1, val);
 149
 150         /* PD15~10, P7~4  ICONFIGA1: AOUT=0x00 */
 151         HAL_READ_UINT32(addr+GPIO_ICONFA1, val);
 152         val = val & ~(0xFFF0FF00);
 153         HAL_WRITE_UINT32(addr+GPIO_ICONFA1, val);
 154
 155         /* PD8  GPR: ALT */
 156         HAL_READ_UINT32(addr+GPIO_GPR, val);
 157         val = val | 0x00000100;
 158         HAL_WRITE_UINT32(addr+GPIO_GPR, val);
 159
 160         /* DDR: OUTPUT */
 161         HAL_READ_UINT32(addr+GPIO_DDIR, val);
 162         val = (val & 0xFFFE0000) | 0x0001020F;
 163         HAL_WRITE_UINT32(addr+GPIO_DDIR, val);
 164
 165         /* GIUS: GPIO */
 166         HAL_READ_UINT32(addr+GPIO_GIUS, val);
 167         val = (val & 0xFFFE0000) | 0x0001FEFF;
 168         HAL_WRITE_UINT32(addr+GPIO_GIUS, val);
 169
 170         /* PB24: */
 171         addr = SOC_GPIOB_BASE;
 172
 173         HAL_READ_UINT32(addr+GPIO_DDIR, val);
 174         val = val | (1<<24);
 175         HAL_WRITE_UINT32(addr+GPIO_DDIR, val);
 176
 177         HAL_READ_UINT32(addr+GPIO_OCR2, val);
 178         val = val | (3<<16);
 179         HAL_WRITE_UINT32(addr+GPIO_OCR2, val);
 180
 181         HAL_READ_UINT32(addr+GPIO_GIUS, val);
 182         val = val | (1<<24);
 183         HAL_WRITE_UINT32(addr+GPIO_GIUS, val);
 184
 185         HAL_READ_UINT32(addr+GPIO_DR, val);
 186         val = val | (1<<24);
 187         HAL_WRITE_UINT32(addr+GPIO_DR, val);
 188 }
 189
 190 static void fec_power_init(void)
 191 {
 192         unsigned long addr , val;
 193
 194         /* Turn on the power of PHY*/
 195         val = pmic_reg(34, val, 0);
 196         val |= (1<<6) | (1<< 10) | (1<<12);
 197         pmic_reg(34, val, 1);
 198
 199         /* Wait until the power is stable*/
 200         for(val = 0; val< 5000; val++)
 201                 hal_delay_us(5);
 202
 203         /*Issue the reset signal*/
 204         addr = SOC_GPIOF_BASE;
 205
 206         HAL_READ_UINT32(addr+GPIO_DR, val);
 207         val = val & (~(1<<10));
 208         HAL_WRITE_UINT32(addr+GPIO_DR, val);
 209
 210         for(val = 0; val< 300; val++)
 211                 hal_delay_us(2);
 212
 213         HAL_READ_UINT32(addr+GPIO_DR, val);
 214         val = val | (1<<10);
 215         HAL_WRITE_UINT32(addr+GPIO_DR, val);
 216
 217         for(val = 0; val< 5000; val++)
 218                 hal_delay_us(5);
 219 }
 220
 221 RedBoot_init(fec_power_init, 9000);
 222
 223 //
 224 // Platform specific initialization
 225 //
 226
 227 unsigned int g_clock_src;
 228 unsigned int g_board_type = BOARD_TYPE_UNKNOWN;
 229
 230 void plf_hardware_init(void)
 231 {
 232     unsigned long val = readl(SOC_CRM_CSCR);
 233
 234     if ((val & (1 << 16)) != 0) {
 235             g_clock_src = FREQ_26MHZ;
 236     } else {
 237         g_clock_src = FREQ_32768HZ;
 238     }
 239
 240     g_board_type = BOARD_TYPE_3STACK;
 241
 242     fec_gpio_init();
 243 }
 244
 245 #include CYGHWR_MEMORY_LAYOUT_H
 246
 247 typedef void code_fun(void);
 248
 249 void board_program_new_stack(void *func)
 250 {
 251     register CYG_ADDRESS stack_ptr asm("sp");
 252     register CYG_ADDRESS old_stack asm("r4");
 253     register code_fun *new_func asm("r0");
 254     old_stack = stack_ptr;
 255     stack_ptr = CYGMEM_REGION_ram + CYGMEM_REGION_ram_SIZE - sizeof(CYG_ADDRESS);
 256     new_func = (code_fun*)func;
 257     new_func();
 258     stack_ptr = old_stack;
 259 }
 260
 261 static void display_clock_src(void)
 262 {
 263     if (g_clock_src == FREQ_26MHZ) {
 264         diag_printf("Clock input: 26 MHz");
 265     } else if (g_clock_src == FREQ_32768HZ) {
 266         diag_printf("Clock input: 32KHz");
 267     } else {
 268         diag_printf("Unknown clock input source. Something is wrong!");
 269     }
 270 }
 271
 272 static void display_board_type(void)
 273 {
 274     if (g_board_type == BOARD_TYPE_3STACK) {
 275         diag_printf("\nBoard Type: 3-Stack\n");
 276     } else {
 277         diag_printf("\nBoard Type: Unknown val %d\n", g_board_type);
 278     }
 279 }
 280
 281 static void display_board_info(void)
 282 {
 283     display_board_type();
 284     display_clock_src();
 285 }
 286
 287 RedBoot_init(display_board_info, RedBoot_INIT_LAST);
 288 // ------------------------------------------------------------------------