Merge branch 'master' into u-boot-5329-early
[platform/kernel/u-boot.git] / 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 <devices.h>
32
33 #ifdef  CONFIG_M5272
34 #include <asm/immap_5272.h>
35 #endif
36
37 #if (CONFIG_COMMANDS & CFG_CMD_IDE)
38 #include <ide.h>
39 #endif
40 #if (CONFIG_COMMANDS & CFG_CMD_SCSI)
41 #include <scsi.h>
42 #endif
43 #if (CONFIG_COMMANDS & CFG_CMD_KGDB)
44 #include <kgdb.h>
45 #endif
46 #ifdef CONFIG_STATUS_LED
47 #include <status_led.h>
48 #endif
49 #include <net.h>
50 #if (CONFIG_COMMANDS & CFG_CMD_BEDBUG)
51 #include <cmd_bedbug.h>
52 #endif
53 #ifdef CFG_ALLOC_DPRAM
54 #include <commproc.h>
55 #endif
56 #include <version.h>
57
58 #if defined(CONFIG_HARD_I2C) || \
59     defined(CONFIG_SOFT_I2C)
60 #include <i2c.h>
61 #endif
62
63 DECLARE_GLOBAL_DATA_PTR;
64
65 static char *failed = "*** failed ***\n";
66
67 #ifdef  CONFIG_PCU_E
68 extern flash_info_t flash_info[];
69 #endif
70
71 #include <environment.h>
72
73 #if ( ((CFG_ENV_ADDR+CFG_ENV_SIZE) < CFG_MONITOR_BASE) || \
74       (CFG_ENV_ADDR >= (CFG_MONITOR_BASE + CFG_MONITOR_LEN)) ) || \
75     defined(CFG_ENV_IS_IN_NVRAM)
76 #define TOTAL_MALLOC_LEN        (CFG_MALLOC_LEN + CFG_ENV_SIZE)
77 #else
78 #define TOTAL_MALLOC_LEN        CFG_MALLOC_LEN
79 #endif
80
81 extern ulong __init_end;
82 extern ulong _end;
83
84 extern  void timer_init(void);
85
86 #if defined(CONFIG_WATCHDOG)
87 # define INIT_FUNC_WATCHDOG_INIT        watchdog_init,
88 # define WATCHDOG_DISABLE               watchdog_disable
89
90 extern int watchdog_init(void);
91 extern int watchdog_disable(void);
92 #else
93 # define INIT_FUNC_WATCHDOG_INIT        /* undef */
94 # define WATCHDOG_DISABLE               /* undef */
95 #endif /* CONFIG_WATCHDOG */
96
97 ulong monitor_flash_len;
98
99 /*
100  * Begin and End of memory area for malloc(), and current "brk"
101  */
102 static  ulong   mem_malloc_start = 0;
103 static  ulong   mem_malloc_end   = 0;
104 static  ulong   mem_malloc_brk   = 0;
105
106 /************************************************************************
107  * Utilities                                                            *
108  ************************************************************************
109  */
110
111 /*
112  * The Malloc area is immediately below the monitor copy in DRAM
113  */
114 static void mem_malloc_init (void)
115 {
116         ulong dest_addr = CFG_MONITOR_BASE + gd->reloc_off;
117
118         mem_malloc_end = dest_addr;
119         mem_malloc_start = dest_addr - TOTAL_MALLOC_LEN;
120         mem_malloc_brk = mem_malloc_start;
121
122         memset ((void *) mem_malloc_start,
123                 0,
124                 mem_malloc_end - mem_malloc_start);
125 }
126
127 void *sbrk (ptrdiff_t increment)
128 {
129         ulong old = mem_malloc_brk;
130         ulong new = old + increment;
131
132         if ((new < mem_malloc_start) ||
133             (new > mem_malloc_end) ) {
134                 return (NULL);
135         }
136         mem_malloc_brk = new;
137         return ((void *)old);
138 }
139
140 char *strmhz(char *buf, long hz)
141 {
142     long l, n;
143     long m;
144
145     n = hz / 1000000L;
146
147     l = sprintf (buf, "%ld", n);
148
149     m = (hz % 1000000L) / 1000L;
150
151     if (m != 0)
152         sprintf (buf+l, ".%03ld", m);
153
154     return (buf);
155 }
156
157 /*
158  * All attempts to come up with a "common" initialization sequence
159  * that works for all boards and architectures failed: some of the
160  * requirements are just _too_ different. To get rid of the resulting
161  * mess of board dependend #ifdef'ed code we now make the whole
162  * initialization sequence configurable to the user.
163  *
164  * The requirements for any new initalization function is simple: it
165  * receives a pointer to the "global data" structure as it's only
166  * argument, and returns an integer return code, where 0 means
167  * "continue" and != 0 means "fatal error, hang the system".
168  */
169 typedef int (init_fnc_t) (void);
170
171 /************************************************************************
172  * Init Utilities                                                       *
173  ************************************************************************
174  * Some of this code should be moved into the core functions,
175  * but let's get it working (again) first...
176  */
177
178 static int init_baudrate (void)
179 {
180         uchar tmp[64];  /* long enough for environment variables */
181         int i = getenv_r ("baudrate", tmp, sizeof (tmp));
182
183         gd->baudrate = (i > 0)
184                         ? (int) simple_strtoul (tmp, NULL, 10)
185                         : CONFIG_BAUDRATE;
186         return (0);
187 }
188
189 /***********************************************************************/
190
191 static int init_func_ram (void)
192 {
193         int board_type = 0;     /* use dummy arg */
194         puts ("DRAM:  ");
195
196         if ((gd->ram_size = initdram (board_type)) > 0) {
197                 print_size (gd->ram_size, "\n");
198                 return (0);
199         }
200         puts (failed);
201         return (1);
202 }
203
204 /***********************************************************************/
205
206 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
207 static int init_func_i2c (void)
208 {
209         puts ("I2C:   ");
210         i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE);
211         puts ("ready\n");
212         return (0);
213 }
214 #endif
215
216 /***********************************************************************/
217
218 /************************************************************************
219  * Initialization sequence                                              *
220  ************************************************************************
221  */
222
223 init_fnc_t *init_sequence[] = {
224     get_clocks,
225         env_init,
226         init_baudrate,
227         serial_init,
228         console_init_f,
229         display_options,
230         checkcpu,
231         checkboard,
232 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
233         init_func_i2c,
234 #endif
235         init_func_ram,
236 #if defined(CFG_DRAM_TEST)
237         testdram,
238 #endif /* CFG_DRAM_TEST */
239         INIT_FUNC_WATCHDOG_INIT
240         NULL,                   /* Terminate this list */
241 };
242
243
244 /************************************************************************
245  *
246  * This is the first part of the initialization sequence that is
247  * implemented in C, but still running from ROM.
248  *
249  * The main purpose is to provide a (serial) console interface as
250  * soon as possible (so we can see any error messages), and to
251  * initialize the RAM so that we can relocate the monitor code to
252  * RAM.
253  *
254  * Be aware of the restrictions: global data is read-only, BSS is not
255  * initialized, and stack space is limited to a few kB.
256  *
257  ************************************************************************
258  */
259
260 void
261 board_init_f (ulong bootflag)
262 {
263         bd_t *bd;
264         ulong len, addr, addr_sp;
265         ulong *paddr;
266         gd_t *id;
267         init_fnc_t **init_fnc_ptr;
268 #ifdef CONFIG_PRAM
269         int i;
270         ulong reg;
271         uchar tmp[64];          /* long enough for environment variables */
272 #endif
273
274         /* Pointer is writable since we allocated a register for it */
275         gd = (gd_t *) (CFG_INIT_RAM_ADDR + CFG_GBL_DATA_OFFSET);
276         /* compiler optimization barrier needed for GCC >= 3.4 */
277         __asm__ __volatile__("": : :"memory");
278
279         /* Clear initial global data */
280         memset ((void *) gd, 0, sizeof (gd_t));
281
282         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
283                 if ((*init_fnc_ptr)() != 0) {
284                         hang ();
285                 }
286         }
287
288         /*
289          * Now that we have DRAM mapped and working, we can
290          * relocate the code and continue running from DRAM.
291          *
292          * Reserve memory at end of RAM for (top down in that order):
293          *      - protected RAM
294          *      - LCD framebuffer
295          *      - monitor code
296          *      - board info struct
297          */
298         len = (ulong)&_end - CFG_MONITOR_BASE;
299
300         addr = CFG_SDRAM_BASE + gd->ram_size;
301
302 #ifdef CONFIG_LOGBUFFER
303         /* reserve kernel log buffer */
304         addr -= (LOGBUFF_RESERVE);
305         debug ("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN, addr);
306 #endif
307
308 #ifdef CONFIG_PRAM
309         /*
310          * reserve protected RAM
311          */
312         i = getenv_r ("pram", tmp, sizeof (tmp));
313         reg = (i > 0) ? simple_strtoul (tmp, NULL, 10) : CONFIG_PRAM;
314         addr -= (reg << 10);            /* size is in kB */
315         debug ("Reserving %ldk for protected RAM at %08lx\n", reg, addr);
316 #endif /* CONFIG_PRAM */
317
318         /*
319          * reserve memory for U-Boot code, data & bss
320          * round down to next 4 kB limit
321          */
322         addr -= len;
323         addr &= ~(4096 - 1);
324
325         debug ("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr);
326
327         /*
328          * reserve memory for malloc() arena
329          */
330         addr_sp = addr - TOTAL_MALLOC_LEN;
331         debug ("Reserving %dk for malloc() at: %08lx\n",
332                         TOTAL_MALLOC_LEN >> 10, addr_sp);
333
334         /*
335          * (permanently) allocate a Board Info struct
336          * and a permanent copy of the "global" data
337          */
338         addr_sp -= sizeof (bd_t);
339         bd = (bd_t *) addr_sp;
340         gd->bd = bd;
341         debug ("Reserving %d Bytes for Board Info at: %08lx\n",
342                         sizeof (bd_t), addr_sp);
343         addr_sp -= sizeof (gd_t);
344         id = (gd_t *) addr_sp;
345         debug ("Reserving %d Bytes for Global Data at: %08lx\n",
346                         sizeof (gd_t), addr_sp);
347
348         /* Reserve memory for boot params. */
349         addr_sp -= CFG_BOOTPARAMS_LEN;
350         bd->bi_boot_params = addr_sp;
351         debug ("Reserving %dk for boot parameters at: %08lx\n",
352                         CFG_BOOTPARAMS_LEN >> 10, addr_sp);
353
354         /*
355          * Finally, we set up a new (bigger) stack.
356          *
357          * Leave some safety gap for SP, force alignment on 16 byte boundary
358          * Clear initial stack frame
359          */
360         addr_sp -= 16;
361         addr_sp &= ~0xF;
362
363         paddr = (ulong *)addr_sp;
364         *paddr-- = 0;
365         *paddr-- = 0;
366         addr_sp = (ulong)paddr;
367
368         debug ("Stack Pointer at: %08lx\n", addr_sp);
369
370         /*
371          * Save local variables to board info struct
372          */
373         bd->bi_memstart  = CFG_SDRAM_BASE;      /* start of  DRAM memory      */
374         bd->bi_memsize   = gd->ram_size;        /* size  of  DRAM memory in bytes */
375 #ifdef CFG_INIT_RAM_ADDR
376         bd->bi_sramstart = CFG_INIT_RAM_ADDR;   /* start of  SRAM memory        */
377         bd->bi_sramsize  = CFG_INIT_RAM_END;    /* size  of  SRAM memory        */
378 #endif
379         bd->bi_mbar_base = CFG_MBAR;            /* base of internal registers */
380
381         bd->bi_bootflags = bootflag;            /* boot / reboot flag (for LynxOS)    */
382
383         WATCHDOG_RESET ();
384         bd->bi_intfreq = gd->cpu_clk;   /* Internal Freq, in Hz */
385         bd->bi_busfreq = gd->bus_clk;   /* Bus Freq,      in Hz */
386         bd->bi_baudrate = gd->baudrate; /* Console Baudrate     */
387
388 #ifdef CFG_EXTBDINFO
389         strncpy (bd->bi_s_version, "1.2", sizeof (bd->bi_s_version));
390         strncpy (bd->bi_r_version, U_BOOT_VERSION, sizeof (bd->bi_r_version));
391 #endif
392
393         WATCHDOG_RESET ();
394
395 #ifdef CONFIG_POST
396         post_bootmode_init();
397         post_run (NULL, POST_ROM | post_bootmode_get(0));
398 #endif
399
400         WATCHDOG_RESET();
401
402         memcpy (id, (void *)gd, sizeof (gd_t));
403
404         debug ("Start relocate of code from %08x to %08lx\n", CFG_MONITOR_BASE, addr);
405         relocate_code (addr_sp, id, addr);
406
407         /* NOTREACHED - jump_to_ram() does not return */
408 }
409
410 /************************************************************************
411  *
412  * This is the next part if the initialization sequence: we are now
413  * running from RAM and have a "normal" C environment, i. e. global
414  * data can be written, BSS has been cleared, the stack size in not
415  * that critical any more, etc.
416  *
417  ************************************************************************
418  */
419 void board_init_r (gd_t *id, ulong dest_addr)
420 {
421         cmd_tbl_t *cmdtp;
422         char *s, *e;
423         bd_t *bd;
424         int i;
425         extern void malloc_bin_reloc (void);
426
427 #ifndef CFG_ENV_IS_NOWHERE
428         extern char * env_name_spec;
429 #endif
430 #ifndef CFG_NO_FLASH
431         ulong flash_size;
432 #endif
433         gd = id;                /* initialize RAM version of global data */
434         bd = gd->bd;
435
436         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
437
438 #ifdef CONFIG_SERIAL_MULTI
439         serial_initialize();
440 #endif
441
442         debug ("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
443
444         WATCHDOG_RESET ();
445
446         gd->reloc_off =  dest_addr - CFG_MONITOR_BASE;
447
448         monitor_flash_len = (ulong)&__init_end - dest_addr;
449
450         /*
451          * We have to relocate the command table manually
452          */
453         for (cmdtp = &__u_boot_cmd_start; cmdtp !=  &__u_boot_cmd_end; cmdtp++) {
454                 ulong addr;
455                 addr = (ulong) (cmdtp->cmd) + gd->reloc_off;
456 #if 0
457                 printf ("Command \"%s\": 0x%08lx => 0x%08lx\n",
458                                 cmdtp->name, (ulong) (cmdtp->cmd), addr);
459 #endif
460                 cmdtp->cmd =
461                         (int (*)(struct cmd_tbl_s *, int, int, char *[]))addr;
462
463                 addr = (ulong)(cmdtp->name) + gd->reloc_off;
464                 cmdtp->name = (char *)addr;
465
466                 if (cmdtp->usage) {
467                         addr = (ulong)(cmdtp->usage) + gd->reloc_off;
468                         cmdtp->usage = (char *)addr;
469                 }
470 #ifdef  CFG_LONGHELP
471                 if (cmdtp->help) {
472                         addr = (ulong)(cmdtp->help) + gd->reloc_off;
473                         cmdtp->help = (char *)addr;
474                 }
475 #endif
476         }
477         /* there are some other pointer constants we must deal with */
478 #ifndef CFG_ENV_IS_NOWHERE
479         env_name_spec += gd->reloc_off;
480 #endif
481
482         WATCHDOG_RESET ();
483
484 #ifdef CONFIG_LOGBUFFER
485         logbuff_init_ptrs ();
486 #endif
487 #ifdef CONFIG_POST
488         post_output_backlog ();
489         post_reloc ();
490 #endif
491         WATCHDOG_RESET();
492
493 #if 0
494         /* instruction cache enabled in cpu_init_f() for faster relocation */
495         icache_enable ();       /* it's time to enable the instruction cache */
496 #endif
497
498         /*
499          * Setup trap handlers
500          */
501         trap_init (CFG_SDRAM_BASE);
502
503 #if !defined(CFG_NO_FLASH)
504         puts ("FLASH: ");
505
506         if ((flash_size = flash_init ()) > 0) {
507 # ifdef CFG_FLASH_CHECKSUM
508                 print_size (flash_size, "");
509                 /*
510                  * Compute and print flash CRC if flashchecksum is set to 'y'
511                  *
512                  * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
513                  */
514                 s = getenv ("flashchecksum");
515                 if (s && (*s == 'y')) {
516                         printf ("  CRC: %08lX",
517                                         crc32 (0,
518                                                    (const unsigned char *) CFG_FLASH_BASE,
519                                                    flash_size)
520                                         );
521                 }
522                 putc ('\n');
523 # else  /* !CFG_FLASH_CHECKSUM */
524                 print_size (flash_size, "\n");
525 # endif /* CFG_FLASH_CHECKSUM */
526         } else {
527                 puts (failed);
528                 hang ();
529         }
530
531         bd->bi_flashstart = CFG_FLASH_BASE;     /* update start of FLASH memory    */
532         bd->bi_flashsize = flash_size;  /* size of FLASH memory (final value) */
533         bd->bi_flashoffset = 0;
534 #else   /* CFG_NO_FLASH */
535         bd->bi_flashsize = 0;
536         bd->bi_flashstart = 0;
537         bd->bi_flashoffset = 0;
538 #endif /* !CFG_NO_FLASH */
539
540         WATCHDOG_RESET ();
541
542         /* initialize higher level parts of CPU like time base and timers */
543         cpu_init_r ();
544
545         WATCHDOG_RESET ();
546
547         /* initialize malloc() area */
548         mem_malloc_init ();
549         malloc_bin_reloc ();
550
551 #ifdef CONFIG_SPI
552 # if !defined(CFG_ENV_IS_IN_EEPROM)
553         spi_init_f ();
554 # endif
555         spi_init_r ();
556 #endif
557
558         /* relocate environment function pointers etc. */
559         env_relocate ();
560
561         /*
562          * Fill in missing fields of bd_info.
563          * We do this here, where we have "normal" access to the
564          * environment; we used to do this still running from ROM,
565          * where had to use getenv_r(), which can be pretty slow when
566          * the environment is in EEPROM.
567          */
568         s = getenv ("ethaddr");
569         for (i = 0; i < 6; ++i) {
570                 bd->bi_enetaddr[i] = s ? simple_strtoul (s, &e, 16) : 0;
571                 if (s)
572                         s = (*e) ? e + 1 : e;
573         }
574 #ifdef CONFIG_HAS_ETH1
575         /* handle the 2nd ethernet address */
576
577         s = getenv ("eth1addr");
578         for (i = 0; i < 6; ++i) {
579                 bd->bi_enet1addr[i] = s ? simple_strtoul (s, &e, 16) : 0;
580                 if (s)
581                         s = (*e) ? e + 1 : e;
582         }
583 #endif
584 #ifdef CONFIG_HAS_ETH2
585         /* handle the 3rd ethernet address */
586
587         s = getenv ("eth2addr");
588         for (i = 0; i < 6; ++i) {
589                 bd->bi_enet2addr[i] = s ? simple_strtoul (s, &e, 16) : 0;
590                 if (s)
591                         s = (*e) ? e + 1 : e;
592         }
593 #endif
594
595 #ifdef CONFIG_HAS_ETH3
596         /* handle 4th ethernet address */
597         s = getenv("eth3addr");
598         for (i = 0; i < 6; ++i) {
599                 bd->bi_enet3addr[i] = s ? simple_strtoul (s, &e, 16) : 0;
600                 if (s)
601                         s = (*e) ? e + 1 : e;
602         }
603 #endif
604
605         /* IP Address */
606         bd->bi_ip_addr = getenv_IPaddr ("ipaddr");
607
608         WATCHDOG_RESET ();
609
610 #if defined(CONFIG_PCI)
611         /*
612          * Do pci configuration
613          */
614         pci_init ();
615 #endif
616
617         /** leave this here (after malloc(), environment and PCI are working) **/
618         /* Initialize devices */
619         devices_init ();
620
621         /* Initialize the jump table for applications */
622         jumptable_init ();
623
624         /* Initialize the console (after the relocation and devices init) */
625         console_init_r ();
626
627 #if defined(CONFIG_MISC_INIT_R)
628         /* miscellaneous platform dependent initialisations */
629         misc_init_r ();
630 #endif
631
632 #if (CONFIG_COMMANDS & CFG_CMD_KGDB)
633         WATCHDOG_RESET ();
634         puts ("KGDB:  ");
635         kgdb_init ();
636 #endif
637
638         debug ("U-Boot relocated to %08lx\n", dest_addr);
639
640         /*
641          * Enable Interrupts
642          */
643         interrupt_init ();
644
645         /* Must happen after interrupts are initialized since
646          * an irq handler gets installed
647          */
648         timer_init();
649
650 #ifdef CONFIG_SERIAL_SOFTWARE_FIFO
651         serial_buffered_init();
652 #endif
653
654 #ifdef CONFIG_STATUS_LED
655         status_led_set (STATUS_LED_BOOT, STATUS_LED_BLINKING);
656 #endif
657
658         udelay (20);
659
660         set_timer (0);
661
662         /* Insert function pointers now that we have relocated the code */
663
664         /* Initialize from environment */
665         if ((s = getenv ("loadaddr")) != NULL) {
666                 load_addr = simple_strtoul (s, NULL, 16);
667         }
668 #if (CONFIG_COMMANDS & CFG_CMD_NET)
669         if ((s = getenv ("bootfile")) != NULL) {
670                 copy_filename (BootFile, s, sizeof (BootFile));
671         }
672 #endif /* CFG_CMD_NET */
673
674         WATCHDOG_RESET ();
675
676 #if (CONFIG_COMMANDS & CFG_CMD_DOC)
677         WATCHDOG_RESET ();
678         puts ("DOC:   ");
679         doc_init ();
680 #endif
681
682 #if (CONFIG_COMMANDS & CFG_CMD_NAND)
683         WATCHDOG_RESET ();
684         puts ("NAND:  ");
685         nand_init();            /* go init the NAND */
686 #endif
687
688 #if (CONFIG_COMMANDS & CFG_CMD_NET)
689         WATCHDOG_RESET();
690 #if defined(FEC_ENET)
691         eth_init(bd);
692 #endif
693 #if defined(CONFIG_NET_MULTI)
694         puts ("Net:   ");
695         eth_initialize (bd);
696 #endif
697 #endif
698
699 #ifdef CONFIG_POST
700         post_run (NULL, POST_RAM | post_bootmode_get(0));
701 #endif
702
703 #if (CONFIG_COMMANDS & CFG_CMD_PCMCIA) && !(CONFIG_COMMANDS & CFG_CMD_IDE)
704         WATCHDOG_RESET ();
705         puts ("PCMCIA:");
706         pcmcia_init ();
707 #endif
708
709 #if (CONFIG_COMMANDS & CFG_CMD_IDE)
710         WATCHDOG_RESET ();
711         puts ("IDE:   ");
712         ide_init ();
713 #endif /* CFG_CMD_IDE */
714
715 #ifdef CONFIG_LAST_STAGE_INIT
716         WATCHDOG_RESET ();
717         /*
718          * Some parts can be only initialized if all others (like
719          * Interrupts) are up and running (i.e. the PC-style ISA
720          * keyboard).
721          */
722         last_stage_init ();
723 #endif
724
725 #if (CONFIG_COMMANDS & CFG_CMD_BEDBUG)
726         WATCHDOG_RESET ();
727         bedbug_init ();
728 #endif
729
730 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
731         /*
732          * Export available size of memory for Linux,
733          * taking into account the protected RAM at top of memory
734          */
735         {
736                 ulong pram;
737                 uchar memsz[32];
738 #ifdef CONFIG_PRAM
739                 char *s;
740
741                 if ((s = getenv ("pram")) != NULL) {
742                         pram = simple_strtoul (s, NULL, 10);
743                 } else {
744                         pram = CONFIG_PRAM;
745                 }
746 #else
747                 pram=0;
748 #endif
749 #ifdef CONFIG_LOGBUFFER
750                 /* Also take the logbuffer into account (pram is in kB) */
751                 pram += (LOGBUFF_LEN+LOGBUFF_OVERHEAD)/1024;
752 #endif
753                 sprintf (memsz, "%ldk", (bd->bi_memsize / 1024) - pram);
754                 setenv ("mem", memsz);
755         }
756 #endif
757
758 #ifdef CONFIG_MODEM_SUPPORT
759  {
760          extern int do_mdm_init;
761          do_mdm_init = gd->do_mdm_init;
762  }
763 #endif
764
765 #ifdef CONFIG_WATCHDOG
766         /* disable watchdog if environment is set */
767         if ((s = getenv ("watchdog")) != NULL) {
768                 if (strncmp (s, "off", 3) == 0) {
769                         WATCHDOG_DISABLE ();
770                 }
771         }
772 #endif /* CONFIG_WATCHDOG*/
773
774
775         /* Initialization complete - start the monitor */
776
777         /* main_loop() can return to retry autoboot, if so just run it again. */
778         for (;;) {
779                 WATCHDOG_RESET ();
780                 main_loop ();
781         }
782
783         /* NOTREACHED - no way out of command loop except booting */
784 }
785
786
787 void hang(void)
788 {
789         puts ("### ERROR ### Please RESET the board ###\n");
790         for (;;);
791 }