arch/nds32/lib/board.c

   1 /*
   2  * (C) Copyright 2002-2006
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * Copyright (C) 2011 Andes Technology Corporation
   6  * Shawn Lin, Andes Technology Corporation <nobuhiro@andestech.com>
   7  * Macpaul Lin, Andes Technology Corporation <macpaul@andestech.com>
   8  *
   9  * SPDX-License-Identifier:     GPL-2.0+
  10  */
  11
  12 #include <common.h>
  13 #include <command.h>
  14 #include <malloc.h>
  15 #include <stdio_dev.h>
  16 #include <timestamp.h>
  17 #include <version.h>
  18 #include <net.h>
  19 #include <serial.h>
  20 #include <nand.h>
  21 #include <onenand_uboot.h>
  22 #include <mmc.h>
  23 #include <asm/sections.h>
  24
  25 DECLARE_GLOBAL_DATA_PTR;
  26
  27 #if defined(CONFIG_SYS_I2C)
  28 #include <i2c.h>
  29 #endif
  30
  31 ulong monitor_flash_len;
  32
  33 /*
  34  * Init Utilities
  35  */
  36
  37 #if !defined(CONFIG_BAUDRATE)
  38 #define CONFIG_BAUDRATE 38400
  39 #endif
  40 static int init_baudrate(void)
  41 {
  42         gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
  43         return 0;
  44 }
  45
  46 /*
  47  * WARNING: this code looks "cleaner" than the PowerPC version, but
  48  * has the disadvantage that you either get nothing, or everything.
  49  * On PowerPC, you might see "DRAM: " before the system hangs - which
  50  * gives a simple yet clear indication which part of the
  51  * initialization if failing.
  52  */
  53 static int display_dram_config(void)
  54 {
  55         int i;
  56
  57 #ifdef DEBUG
  58         puts("RAM Configuration:\n");
  59
  60         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
  61                 printf("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);
  62                 print_size(gd->bd->bi_dram[i].size, "\n");
  63         }
  64 #else
  65         ulong size = 0;
  66
  67         for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++)
  68                 size += gd->bd->bi_dram[i].size;
  69
  70         puts("DRAM:  ");
  71         print_size(size, "\n");
  72 #endif
  73
  74         return 0;
  75 }
  76
  77 #ifndef CONFIG_SYS_NO_FLASH
  78 static void display_flash_config(ulong size)
  79 {
  80         puts("Flash: ");
  81         print_size(size, "\n");
  82 }
  83 #endif /* CONFIG_SYS_NO_FLASH */
  84
  85 #if defined(CONFIG_CMD_PCI) || defined(CONFIG_PCI)
  86 #include <pci.h>
  87 static int nds32_pci_init(void)
  88 {
  89         pci_init();
  90         return 0;
  91 }
  92 #endif /* CONFIG_CMD_PCI || CONFIG_PCI */
  93
  94 #if defined(CONFIG_PMU) || defined(CONFIG_PCU)
  95 #ifndef CONFIG_SKIP_LOWLEVEL_INIT
  96 static int pmu_init(void)
  97 {
  98 #if defined(CONFIG_FTPMU010_POWER)
  99 #ifdef __NDS32_N1213_43U1H__    /* AG101: internal definition in toolchain */
 100         ftpmu010_sdram_clk_disable(CONFIG_SYS_FTPMU010_PDLLCR0_HCLKOUTDIS);
 101         ftpmu010_mfpsr_select_dev(FTPMU010_MFPSR_AC97CLKSEL);
 102         ftpmu010_sdramhtc_set(CONFIG_SYS_FTPMU010_SDRAMHTC);
 103 #endif  /* __NDS32_N1213_43U1H__ */
 104 #endif
 105         return 0;
 106 }
 107 #endif
 108 #endif
 109
 110 /*
 111  * Breathe some life into the board...
 112  *
 113  * Initialize a serial port as console, and carry out some hardware
 114  * tests.
 115  *
 116  * The first part of initialization is running from Flash memory;
 117  * its main purpose is to initialize the RAM so that we
 118  * can relocate the monitor code to RAM.
 119  */
 120
 121 /*
 122  * All attempts to come up with a "common" initialization sequence
 123  * that works for all boards and architectures failed: some of the
 124  * requirements are just _too_ different. To get rid of the resulting
 125  * mess of board dependent #ifdef'ed code we now make the whole
 126  * initialization sequence configurable to the user.
 127  *
 128  * The requirements for any new initalization function is simple: it
 129  * receives a pointer to the "global data" structure as it's only
 130  * argument, and returns an integer return code, where 0 means
 131  * "continue" and != 0 means "fatal error, hang the system".
 132  */
 133 typedef int (init_fnc_t)(void);
 134
 135 void __dram_init_banksize(void)
 136 {
 137         gd->bd->bi_dram[0].start = CONFIG_SYS_SDRAM_BASE;
 138         gd->bd->bi_dram[0].size =  gd->ram_size;
 139 }
 140 void dram_init_banksize(void)
 141         __attribute__((weak, alias("__dram_init_banksize")));
 142
 143 init_fnc_t *init_sequence[] = {
 144 #if defined(CONFIG_ARCH_CPU_INIT)
 145         arch_cpu_init,          /* basic arch cpu dependent setup */
 146 #endif
 147 #if defined(CONFIG_PMU) || defined(CONFIG_PCU)
 148 #ifndef CONFIG_SKIP_LOWLEVEL_INIT
 149         pmu_init,
 150 #endif
 151 #endif
 152         board_init,             /* basic board dependent setup */
 153 #if defined(CONFIG_USE_IRQ)
 154         interrupt_init,         /* set up exceptions */
 155 #endif
 156         timer_init,             /* initialize timer */
 157         env_init,               /* initialize environment */
 158         init_baudrate,          /* initialze baudrate settings */
 159         serial_init,            /* serial communications setup */
 160         console_init_f,         /* stage 1 init of console */
 161 #if defined(CONFIG_DISPLAY_BOARDINFO)
 162         checkboard,             /* display board info */
 163 #endif
 164 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C)
 165         init_func_i2c,
 166 #endif
 167         dram_init,              /* configure available RAM banks */
 168         display_dram_config,
 169         NULL,
 170 };
 171
 172 void board_init_f(ulong bootflag)
 173 {
 174         bd_t *bd;
 175         init_fnc_t **init_fnc_ptr;
 176         gd_t *id;
 177         ulong addr, addr_sp;
 178
 179         /* Pointer is writable since we allocated a register for it */
 180         gd = (gd_t *) ((CONFIG_SYS_INIT_SP_ADDR) & ~0x07);
 181
 182         memset((void *)gd, 0, GENERATED_GBL_DATA_SIZE);
 183
 184         gd->mon_len = (unsigned int)(&__bss_end) - (unsigned int)(&_start);
 185
 186         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
 187                 if ((*init_fnc_ptr)() != 0)
 188                         hang();
 189         }
 190
 191         debug("monitor len: %08lX\n", gd->mon_len);
 192         /*
 193          * Ram is setup, size stored in gd !!
 194          */
 195         debug("ramsize: %08lX\n", gd->ram_size);
 196
 197         addr = CONFIG_SYS_SDRAM_BASE + gd->ram_size;
 198
 199         /* round down to next 4 kB limit */
 200         addr &= ~(4096 - 1);
 201         debug("Top of RAM usable for U-Boot at: %08lx\n", addr);
 202
 203 #ifdef CONFIG_LCD
 204 #ifdef CONFIG_FB_ADDR
 205         gd->fb_base = CONFIG_FB_ADDR;
 206 #else
 207         /* reserve memory for LCD display (always full pages) */
 208         addr = lcd_setmem(addr);
 209         gd->fb_base = addr;
 210 #endif /* CONFIG_FB_ADDR */
 211 #endif /* CONFIG_LCD */
 212
 213         /*
 214          * reserve memory for U-Boot code, data & bss
 215          * round down to next 4 kB limit
 216          */
 217         addr -= gd->mon_len;
 218         addr &= ~(4096 - 1);
 219
 220         debug("Reserving %ldk for U-Boot at: %08lx\n", gd->mon_len >> 10, addr);
 221
 222         /*
 223          * reserve memory for malloc() arena
 224          */
 225         addr_sp = addr - TOTAL_MALLOC_LEN;
 226         debug("Reserving %dk for malloc() at: %08lx\n",
 227                         TOTAL_MALLOC_LEN >> 10, addr_sp);
 228         /*
 229          * (permanently) allocate a Board Info struct
 230          * and a permanent copy of the "global" data
 231          */
 232         addr_sp -= GENERATED_BD_INFO_SIZE;
 233         bd = (bd_t *) addr_sp;
 234         gd->bd = bd;
 235         memset((void *)bd, 0, GENERATED_BD_INFO_SIZE);
 236         debug("Reserving %zu Bytes for Board Info at: %08lx\n",
 237                         GENERATED_BD_INFO_SIZE, addr_sp);
 238
 239         addr_sp -= GENERATED_GBL_DATA_SIZE;
 240         id = (gd_t *) addr_sp;
 241         debug("Reserving %zu Bytes for Global Data at: %08lx\n",
 242                         GENERATED_GBL_DATA_SIZE, addr_sp);
 243
 244         /* setup stackpointer for exeptions */
 245         gd->irq_sp = addr_sp;
 246 #ifdef CONFIG_USE_IRQ
 247         addr_sp -= (CONFIG_STACKSIZE_IRQ + CONFIG_STACKSIZE_FIQ);
 248         debug("Reserving %zu Bytes for IRQ stack at: %08lx\n",
 249                 CONFIG_STACKSIZE_IRQ+CONFIG_STACKSIZE_FIQ, addr_sp);
 250 #endif
 251         /* leave 3 words for abort-stack    */
 252         addr_sp -= 12;
 253
 254         /* 8-byte alignment for ABI compliance */
 255         addr_sp &= ~0x07;
 256         debug("New Stack Pointer is: %08lx\n", addr_sp);
 257
 258         gd->bd->bi_baudrate = gd->baudrate;
 259         /* Ram isn't board specific, so move it to board code ... */
 260         dram_init_banksize();
 261         display_dram_config();  /* and display it */
 262
 263         gd->relocaddr = addr;
 264         gd->start_addr_sp = addr_sp;
 265
 266         gd->reloc_off = addr - _TEXT_BASE;
 267
 268         debug("relocation Offset is: %08lx\n", gd->reloc_off);
 269         memcpy(id, (void *)gd, GENERATED_GBL_DATA_SIZE);
 270
 271         relocate_code(addr_sp, id, addr);
 272
 273         /* NOTREACHED - relocate_code() does not return */
 274 }
 275
 276 /*
 277  * This is the next part if the initialization sequence: we are now
 278  * running from RAM and have a "normal" C environment, i. e. global
 279  * data can be written, BSS has been cleared, the stack size in not
 280  * that critical any more, etc.
 281  */
 282 void board_init_r(gd_t *id, ulong dest_addr)
 283 {
 284         bd_t *bd;
 285         ulong malloc_start;
 286
 287         gd = id;
 288         bd = gd->bd;
 289
 290         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
 291
 292         monitor_flash_len = (ulong)&_end - (ulong)&_start;
 293         debug("monitor flash len: %08lX\n", monitor_flash_len);
 294
 295         board_init();   /* Setup chipselects */
 296
 297 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 298         /*
 299          * We have to relocate the command table manually
 300          */
 301         fixup_cmdtable(ll_entry_start(cmd_tbl_t, cmd),
 302                         ll_entry_count(cmd_tbl_t, cmd));
 303 #endif /* defined(CONFIG_NEEDS_MANUAL_RELOC) */
 304
 305         serial_initialize();
 306
 307         debug("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
 308
 309         /* The Malloc area is immediately below the monitor copy in DRAM */
 310         malloc_start = dest_addr - TOTAL_MALLOC_LEN;
 311         mem_malloc_init(malloc_start, TOTAL_MALLOC_LEN);
 312
 313 #ifndef CONFIG_SYS_NO_FLASH
 314         /* configure available FLASH banks */
 315         gd->bd->bi_flashstart = CONFIG_SYS_FLASH_BASE;
 316         gd->bd->bi_flashsize = flash_init();
 317         gd->bd->bi_flashoffset = CONFIG_SYS_FLASH_BASE + gd->bd->bi_flashsize;
 318
 319         if (gd->bd->bi_flashsize)
 320                         display_flash_config(gd->bd->bi_flashsize);
 321 #endif /* CONFIG_SYS_NO_FLASH */
 322
 323 #if defined(CONFIG_CMD_NAND)
 324         puts("NAND:  ");
 325         nand_init();            /* go init the NAND */
 326 #endif
 327
 328 #if defined(CONFIG_CMD_IDE)
 329         puts("IDE:   ");
 330         ide_init();
 331 #endif
 332
 333 #ifdef CONFIG_GENERIC_MMC
 334         puts("MMC:   ");
 335         mmc_initialize(gd->bd);
 336 #endif
 337
 338 #if defined(CONFIG_SYS_I2C_ADAPTERS)
 339         i2c_reloc_fixup();
 340 #endif
 341
 342         /* initialize environment */
 343         env_relocate();
 344
 345 #if defined(CONFIG_CMD_PCI) || defined(CONFIG_PCI)
 346         puts("PCI:   ");
 347         nds32_pci_init();
 348 #endif
 349
 350         stdio_init();   /* get the devices list going. */
 351
 352         jumptable_init();
 353
 354 #if defined(CONFIG_API)
 355         /* Initialize API */
 356         api_init();
 357 #endif
 358
 359         console_init_r();       /* fully init console as a device */
 360
 361 #if defined(CONFIG_ARCH_MISC_INIT)
 362         /* miscellaneous arch dependent initialisations */
 363         arch_misc_init();
 364 #endif
 365 #if defined(CONFIG_MISC_INIT_R)
 366         /* miscellaneous platform dependent initialisations */
 367         misc_init_r();
 368 #endif
 369
 370 #if defined(CONFIG_USE_IRQ)
 371         /* set up exceptions */
 372         interrupt_init();
 373         /* enable exceptions */
 374         enable_interrupts();
 375 #endif
 376
 377         /* Initialize from environment */
 378         load_addr = getenv_ulong("loadaddr", 16, load_addr);
 379
 380 #ifdef CONFIG_BOARD_LATE_INIT
 381         board_late_init();
 382 #endif
 383
 384 #if defined(CONFIG_CMD_NET)
 385         puts("Net:   ");
 386
 387         eth_initialize(gd->bd);
 388 #if defined(CONFIG_RESET_PHY_R)
 389         debug("Reset Ethernet PHY\n");
 390         reset_phy();
 391 #endif
 392 #endif
 393
 394         /* main_loop() can return to retry autoboot, if so just run it again. */
 395         for (;;)
 396                 main_loop();
 397
 398         /* NOTREACHED - no way out of command loop except booting */
 399 }