lib_m68k/board.c

   1 /*
   2  * (C) Copyright 2003
   3  * Josef Baumgartner <josef.baumgartner@telex.de>
   4  *
   5  * (C) Copyright 2000-2002
   6  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   7  *
   8  * See file CREDITS for list of people who contributed to this
   9  * project.
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License as
  13  * published by the Free Software Foundation; either version 2 of
  14  * the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  24  * MA 02111-1307 USA
  25  */
  26
  27 #include <common.h>
  28 #include <watchdog.h>
  29 #include <command.h>
  30 #include <malloc.h>
  31 #include <stdio_dev.h>
  32
  33 #include <asm/immap.h>
  34
  35 #if defined(CONFIG_CMD_IDE)
  36 #include <ide.h>
  37 #endif
  38 #if defined(CONFIG_CMD_SCSI)
  39 #include <scsi.h>
  40 #endif
  41 #if defined(CONFIG_CMD_KGDB)
  42 #include <kgdb.h>
  43 #endif
  44 #ifdef CONFIG_STATUS_LED
  45 #include <status_led.h>
  46 #endif
  47 #include <net.h>
  48 #include <serial.h>
  49 #if defined(CONFIG_CMD_BEDBUG)
  50 #include <cmd_bedbug.h>
  51 #endif
  52 #ifdef CONFIG_SYS_ALLOC_DPRAM
  53 #include <commproc.h>
  54 #endif
  55 #include <version.h>
  56
  57 #if defined(CONFIG_HARD_I2C) || \
  58     defined(CONFIG_SOFT_I2C)
  59 #include <i2c.h>
  60 #endif
  61
  62 #ifdef CONFIG_CMD_SPI
  63 #include <spi.h>
  64 #endif
  65
  66 #include <nand.h>
  67
  68 DECLARE_GLOBAL_DATA_PTR;
  69
  70 static char *failed = "*** failed ***\n";
  71
  72 #ifdef  CONFIG_PCU_E
  73 extern flash_info_t flash_info[];
  74 #endif
  75
  76 #include <environment.h>
  77
  78 #if ( ((CONFIG_ENV_ADDR+CONFIG_ENV_SIZE) < CONFIG_SYS_MONITOR_BASE) || \
  79       (CONFIG_ENV_ADDR >= (CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN)) ) || \
  80     defined(CONFIG_ENV_IS_IN_NVRAM)
  81 #define TOTAL_MALLOC_LEN        (CONFIG_SYS_MALLOC_LEN + CONFIG_ENV_SIZE)
  82 #else
  83 #define TOTAL_MALLOC_LEN        CONFIG_SYS_MALLOC_LEN
  84 #endif
  85
  86 extern ulong __init_end;
  87 extern ulong _end;
  88
  89 extern  void timer_init(void);
  90
  91 #if defined(CONFIG_WATCHDOG)
  92 # define INIT_FUNC_WATCHDOG_INIT        watchdog_init,
  93 # define WATCHDOG_DISABLE               watchdog_disable
  94
  95 extern int watchdog_init(void);
  96 extern int watchdog_disable(void);
  97 #else
  98 # define INIT_FUNC_WATCHDOG_INIT        /* undef */
  99 # define WATCHDOG_DISABLE               /* undef */
 100 #endif /* CONFIG_WATCHDOG */
 101
 102 ulong monitor_flash_len;
 103
 104 /************************************************************************
 105  * Utilities                                                            *
 106  ************************************************************************
 107  */
 108
 109 /*
 110  * The Malloc area is immediately below the monitor copy in DRAM
 111  */
 112 static void mem_malloc_init(ulong start, ulong size)
 113 {
 114         mem_malloc_start = start;
 115         mem_malloc_end = start + size;
 116         mem_malloc_brk = start;
 117
 118         memset ((void *)mem_malloc_start, 0, size);
 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 dependend #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 /************************************************************************
 136  * Init Utilities
 137  ************************************************************************
 138  * Some of this code should be moved into the core functions,
 139  * but let's get it working (again) first...
 140  */
 141
 142 static int init_baudrate (void)
 143 {
 144         char tmp[64];   /* long enough for environment variables */
 145         int i = getenv_r ("baudrate", tmp, sizeof (tmp));
 146
 147         gd->baudrate = (i > 0)
 148                         ? (int) simple_strtoul (tmp, NULL, 10)
 149                         : CONFIG_BAUDRATE;
 150         return (0);
 151 }
 152
 153 /***********************************************************************/
 154
 155 static int init_func_ram (void)
 156 {
 157         int board_type = 0;     /* use dummy arg */
 158         puts ("DRAM:  ");
 159
 160         if ((gd->ram_size = initdram (board_type)) > 0) {
 161                 print_size (gd->ram_size, "\n");
 162                 return (0);
 163         }
 164         puts (failed);
 165         return (1);
 166 }
 167
 168 /***********************************************************************/
 169
 170 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
 171 static int init_func_i2c (void)
 172 {
 173         puts ("I2C:   ");
 174         i2c_init (CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
 175         puts ("ready\n");
 176         return (0);
 177 }
 178 #endif
 179
 180 #if defined(CONFIG_HARD_SPI)
 181 static int init_func_spi (void)
 182 {
 183         puts ("SPI:   ");
 184         spi_init ();
 185         puts ("ready\n");
 186         return (0);
 187 }
 188 #endif
 189
 190 /***********************************************************************/
 191
 192 /************************************************************************
 193  * Initialization sequence                                              *
 194  ************************************************************************
 195  */
 196
 197 init_fnc_t *init_sequence[] = {
 198         get_clocks,
 199         env_init,
 200         init_baudrate,
 201         serial_init,
 202         console_init_f,
 203         display_options,
 204         checkcpu,
 205         checkboard,
 206 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
 207         init_func_i2c,
 208 #endif
 209 #if defined(CONFIG_HARD_SPI)
 210         init_func_spi,
 211 #endif
 212         init_func_ram,
 213 #if defined(CONFIG_SYS_DRAM_TEST)
 214         testdram,
 215 #endif /* CONFIG_SYS_DRAM_TEST */
 216         INIT_FUNC_WATCHDOG_INIT
 217         NULL,                   /* Terminate this list */
 218 };
 219
 220
 221 /************************************************************************
 222  *
 223  * This is the first part of the initialization sequence that is
 224  * implemented in C, but still running from ROM.
 225  *
 226  * The main purpose is to provide a (serial) console interface as
 227  * soon as possible (so we can see any error messages), and to
 228  * initialize the RAM so that we can relocate the monitor code to
 229  * RAM.
 230  *
 231  * Be aware of the restrictions: global data is read-only, BSS is not
 232  * initialized, and stack space is limited to a few kB.
 233  *
 234  ************************************************************************
 235  */
 236
 237 void
 238 board_init_f (ulong bootflag)
 239 {
 240         bd_t *bd;
 241         ulong len, addr, addr_sp;
 242         ulong *paddr;
 243         gd_t *id;
 244         init_fnc_t **init_fnc_ptr;
 245 #ifdef CONFIG_PRAM
 246         int i;
 247         ulong reg;
 248         char tmp[64];           /* long enough for environment variables */
 249 #endif
 250
 251         /* Pointer is writable since we allocated a register for it */
 252         gd = (gd_t *) (CONFIG_SYS_INIT_RAM_ADDR + CONFIG_SYS_GBL_DATA_OFFSET);
 253         /* compiler optimization barrier needed for GCC >= 3.4 */
 254         __asm__ __volatile__("": : :"memory");
 255
 256         /* Clear initial global data */
 257         memset ((void *) gd, 0, sizeof (gd_t));
 258
 259         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
 260                 if ((*init_fnc_ptr)() != 0) {
 261                         hang ();
 262                 }
 263         }
 264
 265         /*
 266          * Now that we have DRAM mapped and working, we can
 267          * relocate the code and continue running from DRAM.
 268          *
 269          * Reserve memory at end of RAM for (top down in that order):
 270          *      - protected RAM
 271          *      - LCD framebuffer
 272          *      - monitor code
 273          *      - board info struct
 274          */
 275         len = (ulong)&_end - CONFIG_SYS_MONITOR_BASE;
 276
 277         addr = CONFIG_SYS_SDRAM_BASE + gd->ram_size;
 278
 279 #ifdef CONFIG_LOGBUFFER
 280         /* reserve kernel log buffer */
 281         addr -= (LOGBUFF_RESERVE);
 282         debug ("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN, addr);
 283 #endif
 284
 285 #ifdef CONFIG_PRAM
 286         /*
 287          * reserve protected RAM
 288          */
 289         i = getenv_r ("pram", tmp, sizeof (tmp));
 290         reg = (i > 0) ? simple_strtoul (tmp, NULL, 10) : CONFIG_PRAM;
 291         addr -= (reg << 10);            /* size is in kB */
 292         debug ("Reserving %ldk for protected RAM at %08lx\n", reg, addr);
 293 #endif /* CONFIG_PRAM */
 294
 295         /* round down to next 4 kB limit */
 296         addr &= ~(4096 - 1);
 297         debug ("Top of RAM usable for U-Boot at: %08lx\n", addr);
 298
 299 #ifdef CONFIG_LCD
 300         /* reserve memory for LCD display (always full pages) */
 301         addr = lcd_setmem (addr);
 302         gd->fb_base = addr;
 303 #endif /* CONFIG_LCD */
 304
 305         /*
 306          * reserve memory for U-Boot code, data & bss
 307          * round down to next 4 kB limit
 308          */
 309         addr -= len;
 310         addr &= ~(4096 - 1);
 311
 312         debug ("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr);
 313
 314         /*
 315          * reserve memory for malloc() arena
 316          */
 317         addr_sp = addr - TOTAL_MALLOC_LEN;
 318         debug ("Reserving %dk for malloc() at: %08lx\n",
 319                         TOTAL_MALLOC_LEN >> 10, addr_sp);
 320
 321         /*
 322          * (permanently) allocate a Board Info struct
 323          * and a permanent copy of the "global" data
 324          */
 325         addr_sp -= sizeof (bd_t);
 326         bd = (bd_t *) addr_sp;
 327         gd->bd = bd;
 328         debug ("Reserving %zu Bytes for Board Info at: %08lx\n",
 329                         sizeof (bd_t), addr_sp);
 330         addr_sp -= sizeof (gd_t);
 331         id = (gd_t *) addr_sp;
 332         debug ("Reserving %zu Bytes for Global Data at: %08lx\n",
 333                         sizeof (gd_t), addr_sp);
 334
 335         /* Reserve memory for boot params. */
 336         addr_sp -= CONFIG_SYS_BOOTPARAMS_LEN;
 337         bd->bi_boot_params = addr_sp;
 338         debug ("Reserving %dk for boot parameters at: %08lx\n",
 339                         CONFIG_SYS_BOOTPARAMS_LEN >> 10, addr_sp);
 340
 341         /*
 342          * Finally, we set up a new (bigger) stack.
 343          *
 344          * Leave some safety gap for SP, force alignment on 16 byte boundary
 345          * Clear initial stack frame
 346          */
 347         addr_sp -= 16;
 348         addr_sp &= ~0xF;
 349
 350         paddr = (ulong *)addr_sp;
 351         *paddr-- = 0;
 352         *paddr-- = 0;
 353         addr_sp = (ulong)paddr;
 354
 355         debug ("Stack Pointer at: %08lx\n", addr_sp);
 356
 357         /*
 358          * Save local variables to board info struct
 359          */
 360         bd->bi_memstart  = CONFIG_SYS_SDRAM_BASE;       /* start of  DRAM memory      */
 361         bd->bi_memsize   = gd->ram_size;        /* size  of  DRAM memory in bytes */
 362 #ifdef CONFIG_SYS_INIT_RAM_ADDR
 363         bd->bi_sramstart = CONFIG_SYS_INIT_RAM_ADDR;    /* start of  SRAM memory        */
 364         bd->bi_sramsize  = CONFIG_SYS_INIT_RAM_END;     /* size  of  SRAM memory        */
 365 #endif
 366         bd->bi_mbar_base = CONFIG_SYS_MBAR;             /* base of internal registers */
 367
 368         bd->bi_bootflags = bootflag;            /* boot / reboot flag (for LynxOS)    */
 369
 370         WATCHDOG_RESET ();
 371         bd->bi_intfreq = gd->cpu_clk;   /* Internal Freq, in Hz */
 372         bd->bi_busfreq = gd->bus_clk;   /* Bus Freq,      in Hz */
 373 #ifdef CONFIG_PCI
 374         bd->bi_pcifreq = gd->pci_clk;           /* PCI Freq in Hz */
 375 #endif
 376 #ifdef CONFIG_EXTRA_CLOCK
 377         bd->bi_inpfreq = gd->inp_clk;           /* input Freq in Hz */
 378         bd->bi_vcofreq = gd->vco_clk;           /* vco Freq in Hz */
 379         bd->bi_flbfreq = gd->flb_clk;           /* flexbus Freq in Hz */
 380 #endif
 381         bd->bi_baudrate = gd->baudrate; /* Console Baudrate     */
 382
 383 #ifdef CONFIG_SYS_EXTBDINFO
 384         strncpy (bd->bi_s_version, "1.2", sizeof (bd->bi_s_version));
 385         strncpy (bd->bi_r_version, U_BOOT_VERSION, sizeof (bd->bi_r_version));
 386 #endif
 387
 388         WATCHDOG_RESET ();
 389
 390 #ifdef CONFIG_POST
 391         post_bootmode_init();
 392         post_run (NULL, POST_ROM | post_bootmode_get(0));
 393 #endif
 394
 395         WATCHDOG_RESET();
 396
 397         memcpy (id, (void *)gd, sizeof (gd_t));
 398
 399         debug ("Start relocate of code from %08x to %08lx\n", CONFIG_SYS_MONITOR_BASE, addr);
 400         relocate_code (addr_sp, id, addr);
 401
 402         /* NOTREACHED - jump_to_ram() does not return */
 403 }
 404
 405 /************************************************************************
 406  *
 407  * This is the next part if the initialization sequence: we are now
 408  * running from RAM and have a "normal" C environment, i. e. global
 409  * data can be written, BSS has been cleared, the stack size in not
 410  * that critical any more, etc.
 411  *
 412  ************************************************************************
 413  */
 414 void board_init_r (gd_t *id, ulong dest_addr)
 415 {
 416         cmd_tbl_t *cmdtp;
 417         char *s;
 418         bd_t *bd;
 419         extern void malloc_bin_reloc (void);
 420
 421 #ifndef CONFIG_ENV_IS_NOWHERE
 422         extern char * env_name_spec;
 423 #endif
 424 #ifndef CONFIG_SYS_NO_FLASH
 425         ulong flash_size;
 426 #endif
 427         gd = id;                /* initialize RAM version of global data */
 428         bd = gd->bd;
 429
 430         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
 431
 432 #ifdef CONFIG_SERIAL_MULTI
 433         serial_initialize();
 434 #endif
 435
 436         debug ("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
 437
 438         WATCHDOG_RESET ();
 439
 440         gd->reloc_off =  dest_addr - CONFIG_SYS_MONITOR_BASE;
 441
 442         monitor_flash_len = (ulong)&__init_end - dest_addr;
 443
 444         /*
 445          * We have to relocate the command table manually
 446          */
 447         for (cmdtp = &__u_boot_cmd_start; cmdtp !=  &__u_boot_cmd_end; cmdtp++) {
 448                 ulong addr;
 449                 addr = (ulong) (cmdtp->cmd) + gd->reloc_off;
 450 #if 0
 451                 printf ("Command \"%s\": 0x%08lx => 0x%08lx\n",
 452                                 cmdtp->name, (ulong) (cmdtp->cmd), addr);
 453 #endif
 454                 cmdtp->cmd =
 455                         (int (*)(struct cmd_tbl_s *, int, int, char *[]))addr;
 456
 457                 addr = (ulong)(cmdtp->name) + gd->reloc_off;
 458                 cmdtp->name = (char *)addr;
 459
 460                 if (cmdtp->usage) {
 461                         addr = (ulong)(cmdtp->usage) + gd->reloc_off;
 462                         cmdtp->usage = (char *)addr;
 463                 }
 464 #ifdef  CONFIG_SYS_LONGHELP
 465                 if (cmdtp->help) {
 466                         addr = (ulong)(cmdtp->help) + gd->reloc_off;
 467                         cmdtp->help = (char *)addr;
 468                 }
 469 #endif
 470         }
 471         /* there are some other pointer constants we must deal with */
 472 #ifndef CONFIG_ENV_IS_NOWHERE
 473         env_name_spec += gd->reloc_off;
 474 #endif
 475
 476         WATCHDOG_RESET ();
 477
 478 #ifdef CONFIG_LOGBUFFER
 479         logbuff_init_ptrs ();
 480 #endif
 481 #ifdef CONFIG_POST
 482         post_output_backlog ();
 483         post_reloc ();
 484 #endif
 485         WATCHDOG_RESET();
 486
 487 #if 0
 488         /* instruction cache enabled in cpu_init_f() for faster relocation */
 489         icache_enable ();       /* it's time to enable the instruction cache */
 490 #endif
 491
 492         /*
 493          * Setup trap handlers
 494          */
 495         trap_init (CONFIG_SYS_SDRAM_BASE);
 496
 497         /* initialize malloc() area */
 498         mem_malloc_init (CONFIG_SYS_MONITOR_BASE + gd->reloc_off -
 499                         TOTAL_MALLOC_LEN, TOTAL_MALLOC_LEN);
 500         malloc_bin_reloc ();
 501
 502 #if !defined(CONFIG_SYS_NO_FLASH)
 503         puts ("FLASH: ");
 504
 505         if ((flash_size = flash_init ()) > 0) {
 506 # ifdef CONFIG_SYS_FLASH_CHECKSUM
 507                 print_size (flash_size, "");
 508                 /*
 509                  * Compute and print flash CRC if flashchecksum is set to 'y'
 510                  *
 511                  * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
 512                  */
 513                 s = getenv ("flashchecksum");
 514                 if (s && (*s == 'y')) {
 515                         printf ("  CRC: %08X",
 516                                         crc32 (0,
 517                                                    (const unsigned char *) CONFIG_SYS_FLASH_BASE,
 518                                                    flash_size)
 519                                         );
 520                 }
 521                 putc ('\n');
 522 # else  /* !CONFIG_SYS_FLASH_CHECKSUM */
 523                 print_size (flash_size, "\n");
 524 # endif /* CONFIG_SYS_FLASH_CHECKSUM */
 525         } else {
 526                 puts (failed);
 527                 hang ();
 528         }
 529
 530         bd->bi_flashstart = CONFIG_SYS_FLASH_BASE;      /* update start of FLASH memory    */
 531         bd->bi_flashsize = flash_size;  /* size of FLASH memory (final value) */
 532         bd->bi_flashoffset = 0;
 533 #else   /* CONFIG_SYS_NO_FLASH */
 534         bd->bi_flashsize = 0;
 535         bd->bi_flashstart = 0;
 536         bd->bi_flashoffset = 0;
 537 #endif /* !CONFIG_SYS_NO_FLASH */
 538
 539         WATCHDOG_RESET ();
 540
 541         /* initialize higher level parts of CPU like time base and timers */
 542         cpu_init_r ();
 543
 544         WATCHDOG_RESET ();
 545
 546 #ifdef CONFIG_SPI
 547 # if !defined(CONFIG_ENV_IS_IN_EEPROM)
 548         spi_init_f ();
 549 # endif
 550         spi_init_r ();
 551 #endif
 552
 553         /* relocate environment function pointers etc. */
 554         env_relocate ();
 555
 556         /*
 557          * Fill in missing fields of bd_info.
 558          * We do this here, where we have "normal" access to the
 559          * environment; we used to do this still running from ROM,
 560          * where had to use getenv_r(), which can be pretty slow when
 561          * the environment is in EEPROM.
 562          */
 563         bd->bi_ip_addr = getenv_IPaddr ("ipaddr");
 564
 565         WATCHDOG_RESET ();
 566
 567 #if defined(CONFIG_PCI)
 568         /*
 569          * Do pci configuration
 570          */
 571         pci_init ();
 572 #endif
 573
 574         /** leave this here (after malloc(), environment and PCI are working) **/
 575         /* Initialize stdio devices */
 576         stdio_init ();
 577
 578         /* Initialize the jump table for applications */
 579         jumptable_init ();
 580
 581         /* Initialize the console (after the relocation and devices init) */
 582         console_init_r ();
 583
 584 #if defined(CONFIG_MISC_INIT_R)
 585         /* miscellaneous platform dependent initialisations */
 586         misc_init_r ();
 587 #endif
 588
 589 #if defined(CONFIG_CMD_KGDB)
 590         WATCHDOG_RESET ();
 591         puts ("KGDB:  ");
 592         kgdb_init ();
 593 #endif
 594
 595         debug ("U-Boot relocated to %08lx\n", dest_addr);
 596
 597         /*
 598          * Enable Interrupts
 599          */
 600         interrupt_init ();
 601
 602         /* Must happen after interrupts are initialized since
 603          * an irq handler gets installed
 604          */
 605         timer_init();
 606
 607 #ifdef CONFIG_SERIAL_SOFTWARE_FIFO
 608         serial_buffered_init();
 609 #endif
 610
 611 #ifdef CONFIG_STATUS_LED
 612         status_led_set (STATUS_LED_BOOT, STATUS_LED_BLINKING);
 613 #endif
 614
 615         udelay (20);
 616
 617         set_timer (0);
 618
 619         /* Insert function pointers now that we have relocated the code */
 620
 621         /* Initialize from environment */
 622         if ((s = getenv ("loadaddr")) != NULL) {
 623                 load_addr = simple_strtoul (s, NULL, 16);
 624         }
 625 #if defined(CONFIG_CMD_NET)
 626         if ((s = getenv ("bootfile")) != NULL) {
 627                 copy_filename (BootFile, s, sizeof (BootFile));
 628         }
 629 #endif
 630
 631         WATCHDOG_RESET ();
 632
 633 #if defined(CONFIG_CMD_DOC)
 634         WATCHDOG_RESET ();
 635         puts ("DOC:   ");
 636         doc_init ();
 637 #endif
 638
 639 #if defined(CONFIG_CMD_NAND)
 640         WATCHDOG_RESET ();
 641         puts ("NAND:  ");
 642         nand_init();            /* go init the NAND */
 643 #endif
 644
 645 #if defined(CONFIG_CMD_NET)
 646         WATCHDOG_RESET();
 647 #if defined(FEC_ENET)
 648         eth_init(bd);
 649 #endif
 650 #if defined(CONFIG_NET_MULTI)
 651         puts ("Net:   ");
 652         eth_initialize (bd);
 653 #endif
 654 #endif
 655
 656 #ifdef CONFIG_POST
 657         post_run (NULL, POST_RAM | post_bootmode_get(0));
 658 #endif
 659
 660 #if defined(CONFIG_CMD_PCMCIA) \
 661     && !defined(CONFIG_CMD_IDE)
 662         WATCHDOG_RESET ();
 663         puts ("PCMCIA:");
 664         pcmcia_init ();
 665 #endif
 666
 667 #if defined(CONFIG_CMD_IDE)
 668         WATCHDOG_RESET ();
 669         puts ("IDE:   ");
 670         ide_init ();
 671 #endif
 672
 673 #ifdef CONFIG_LAST_STAGE_INIT
 674         WATCHDOG_RESET ();
 675         /*
 676          * Some parts can be only initialized if all others (like
 677          * Interrupts) are up and running (i.e. the PC-style ISA
 678          * keyboard).
 679          */
 680         last_stage_init ();
 681 #endif
 682
 683 #if defined(CONFIG_CMD_BEDBUG)
 684         WATCHDOG_RESET ();
 685         bedbug_init ();
 686 #endif
 687
 688 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
 689         /*
 690          * Export available size of memory for Linux,
 691          * taking into account the protected RAM at top of memory
 692          */
 693         {
 694                 ulong pram;
 695                 char memsz[32];
 696 #ifdef CONFIG_PRAM
 697                 char *s;
 698
 699                 if ((s = getenv ("pram")) != NULL) {
 700                         pram = simple_strtoul (s, NULL, 10);
 701                 } else {
 702                         pram = CONFIG_PRAM;
 703                 }
 704 #else
 705                 pram=0;
 706 #endif
 707 #ifdef CONFIG_LOGBUFFER
 708                 /* Also take the logbuffer into account (pram is in kB) */
 709                 pram += (LOGBUFF_LEN+LOGBUFF_OVERHEAD)/1024;
 710 #endif
 711                 sprintf (memsz, "%ldk", (bd->bi_memsize / 1024) - pram);
 712                 setenv ("mem", memsz);
 713         }
 714 #endif
 715
 716 #ifdef CONFIG_MODEM_SUPPORT
 717  {
 718          extern int do_mdm_init;
 719          do_mdm_init = gd->do_mdm_init;
 720  }
 721 #endif
 722
 723 #ifdef CONFIG_WATCHDOG
 724         /* disable watchdog if environment is set */
 725         if ((s = getenv ("watchdog")) != NULL) {
 726                 if (strncmp (s, "off", 3) == 0) {
 727                         WATCHDOG_DISABLE ();
 728                 }
 729         }
 730 #endif /* CONFIG_WATCHDOG*/
 731
 732
 733         /* Initialization complete - start the monitor */
 734
 735         /* main_loop() can return to retry autoboot, if so just run it again. */
 736         for (;;) {
 737                 WATCHDOG_RESET ();
 738                 main_loop ();
 739         }
 740
 741         /* NOTREACHED - no way out of command loop except booting */
 742 }
 743
 744
 745 void hang(void)
 746 {
 747         puts ("### ERROR ### Please RESET the board ###\n");
 748         for (;;);
 749 }