Merge branch 'mpc86xx'
[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         env_init,
225         init_baudrate,
226         serial_init,
227         console_init_f,
228         display_options,
229         checkcpu,
230         checkboard,
231 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
232         init_func_i2c,
233 #endif
234         init_func_ram,
235 #if defined(CFG_DRAM_TEST)
236         testdram,
237 #endif /* CFG_DRAM_TEST */
238         INIT_FUNC_WATCHDOG_INIT
239         NULL,                   /* Terminate this list */
240 };
241
242
243 /************************************************************************
244  *
245  * This is the first part of the initialization sequence that is
246  * implemented in C, but still running from ROM.
247  *
248  * The main purpose is to provide a (serial) console interface as
249  * soon as possible (so we can see any error messages), and to
250  * initialize the RAM so that we can relocate the monitor code to
251  * RAM.
252  *
253  * Be aware of the restrictions: global data is read-only, BSS is not
254  * initialized, and stack space is limited to a few kB.
255  *
256  ************************************************************************
257  */
258
259 void
260 board_init_f (ulong bootflag)
261 {
262         bd_t *bd;
263         ulong len, addr, addr_sp;
264         ulong *paddr;
265         gd_t *id;
266         init_fnc_t **init_fnc_ptr;
267 #ifdef CONFIG_PRAM
268         int i;
269         ulong reg;
270         uchar tmp[64];          /* long enough for environment variables */
271 #endif
272
273         /* Pointer is writable since we allocated a register for it */
274         gd = (gd_t *) (CFG_INIT_RAM_ADDR + CFG_GBL_DATA_OFFSET);
275         /* compiler optimization barrier needed for GCC >= 3.4 */
276         __asm__ __volatile__("": : :"memory");
277
278         /* Clear initial global data */
279         memset ((void *) gd, 0, sizeof (gd_t));
280
281         for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
282                 if ((*init_fnc_ptr)() != 0) {
283                         hang ();
284                 }
285         }
286
287         /*
288          * Now that we have DRAM mapped and working, we can
289          * relocate the code and continue running from DRAM.
290          *
291          * Reserve memory at end of RAM for (top down in that order):
292          *      - protected RAM
293          *      - LCD framebuffer
294          *      - monitor code
295          *      - board info struct
296          */
297         len = (ulong)&_end - CFG_MONITOR_BASE;
298
299         addr = CFG_SDRAM_BASE + gd->ram_size;
300
301 #ifdef CONFIG_LOGBUFFER
302         /* reserve kernel log buffer */
303         addr -= (LOGBUFF_RESERVE);
304         debug ("Reserving %dk for kernel logbuffer at %08lx\n", LOGBUFF_LEN, addr);
305 #endif
306
307 #ifdef CONFIG_PRAM
308         /*
309          * reserve protected RAM
310          */
311         i = getenv_r ("pram", tmp, sizeof (tmp));
312         reg = (i > 0) ? simple_strtoul (tmp, NULL, 10) : CONFIG_PRAM;
313         addr -= (reg << 10);            /* size is in kB */
314         debug ("Reserving %ldk for protected RAM at %08lx\n", reg, addr);
315 #endif /* CONFIG_PRAM */
316
317         /*
318          * reserve memory for U-Boot code, data & bss
319          * round down to next 4 kB limit
320          */
321         addr -= len;
322         addr &= ~(4096 - 1);
323
324         debug ("Reserving %ldk for U-Boot at: %08lx\n", len >> 10, addr);
325
326         /*
327          * reserve memory for malloc() arena
328          */
329         addr_sp = addr - TOTAL_MALLOC_LEN;
330         debug ("Reserving %dk for malloc() at: %08lx\n",
331                         TOTAL_MALLOC_LEN >> 10, addr_sp);
332
333         /*
334          * (permanently) allocate a Board Info struct
335          * and a permanent copy of the "global" data
336          */
337         addr_sp -= sizeof (bd_t);
338         bd = (bd_t *) addr_sp;
339         gd->bd = bd;
340         debug ("Reserving %d Bytes for Board Info at: %08lx\n",
341                         sizeof (bd_t), addr_sp);
342         addr_sp -= sizeof (gd_t);
343         id = (gd_t *) addr_sp;
344         debug ("Reserving %d Bytes for Global Data at: %08lx\n",
345                         sizeof (gd_t), addr_sp);
346
347         /* Reserve memory for boot params. */
348         addr_sp -= CFG_BOOTPARAMS_LEN;
349         bd->bi_boot_params = addr_sp;
350         debug ("Reserving %dk for boot parameters at: %08lx\n",
351                         CFG_BOOTPARAMS_LEN >> 10, addr_sp);
352
353         /*
354          * Finally, we set up a new (bigger) stack.
355          *
356          * Leave some safety gap for SP, force alignment on 16 byte boundary
357          * Clear initial stack frame
358          */
359         addr_sp -= 16;
360         addr_sp &= ~0xF;
361
362         paddr = (ulong *)addr_sp;
363         *paddr-- = 0;
364         *paddr-- = 0;
365         addr_sp = (ulong)paddr;
366
367         debug ("Stack Pointer at: %08lx\n", addr_sp);
368
369         /*
370          * Save local variables to board info struct
371          */
372         bd->bi_memstart  = CFG_SDRAM_BASE;      /* start of  DRAM memory      */
373         bd->bi_memsize   = gd->ram_size;        /* size  of  DRAM memory in bytes */
374         bd->bi_mbar_base = CFG_MBAR;            /* base of internal registers */
375
376         bd->bi_bootflags = bootflag;            /* boot / reboot flag (for LynxOS)    */
377
378         WATCHDOG_RESET ();
379         bd->bi_intfreq = gd->cpu_clk;   /* Internal Freq, in Hz */
380         bd->bi_busfreq = gd->bus_clk;   /* Bus Freq,      in Hz */
381         bd->bi_baudrate = gd->baudrate; /* Console Baudrate     */
382
383 #ifdef CFG_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", CFG_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, *e;
418         bd_t *bd;
419         int i;
420         extern void malloc_bin_reloc (void);
421
422 #ifndef CFG_ENV_IS_NOWHERE
423         extern char * env_name_spec;
424 #endif
425 #ifndef CFG_NO_FLASH
426         ulong flash_size;
427 #endif
428         gd = id;                /* initialize RAM version of global data */
429         bd = gd->bd;
430
431         gd->flags |= GD_FLG_RELOC;      /* tell others: relocation done */
432
433         debug ("Now running in RAM - U-Boot at: %08lx\n", dest_addr);
434
435         WATCHDOG_RESET ();
436
437         gd->reloc_off =  dest_addr - CFG_MONITOR_BASE;
438
439         monitor_flash_len = (ulong)&__init_end - dest_addr;
440
441         /*
442          * We have to relocate the command table manually
443          */
444         for (cmdtp = &__u_boot_cmd_start; cmdtp !=  &__u_boot_cmd_end; cmdtp++) {
445                 ulong addr;
446                 addr = (ulong) (cmdtp->cmd) + gd->reloc_off;
447 #if 0
448                 printf ("Command \"%s\": 0x%08lx => 0x%08lx\n",
449                                 cmdtp->name, (ulong) (cmdtp->cmd), addr);
450 #endif
451                 cmdtp->cmd =
452                         (int (*)(struct cmd_tbl_s *, int, int, char *[]))addr;
453
454                 addr = (ulong)(cmdtp->name) + gd->reloc_off;
455                 cmdtp->name = (char *)addr;
456
457                 if (cmdtp->usage) {
458                         addr = (ulong)(cmdtp->usage) + gd->reloc_off;
459                         cmdtp->usage = (char *)addr;
460                 }
461 #ifdef  CFG_LONGHELP
462                 if (cmdtp->help) {
463                         addr = (ulong)(cmdtp->help) + gd->reloc_off;
464                         cmdtp->help = (char *)addr;
465                 }
466 #endif
467         }
468         /* there are some other pointer constants we must deal with */
469 #ifndef CFG_ENV_IS_NOWHERE
470         env_name_spec += gd->reloc_off;
471 #endif
472
473         WATCHDOG_RESET ();
474
475 #ifdef CONFIG_LOGBUFFER
476         logbuff_init_ptrs ();
477 #endif
478 #ifdef CONFIG_POST
479         post_output_backlog ();
480         post_reloc ();
481 #endif
482         WATCHDOG_RESET();
483
484 #if 0
485         /* instruction cache enabled in cpu_init_f() for faster relocation */
486         icache_enable ();       /* it's time to enable the instruction cache */
487 #endif
488
489         /*
490          * Setup trap handlers
491          */
492         trap_init (0);
493
494 #if !defined(CFG_NO_FLASH)
495         puts ("FLASH: ");
496
497         if ((flash_size = flash_init ()) > 0) {
498 # ifdef CFG_FLASH_CHECKSUM
499                 print_size (flash_size, "");
500                 /*
501                  * Compute and print flash CRC if flashchecksum is set to 'y'
502                  *
503                  * NOTE: Maybe we should add some WATCHDOG_RESET()? XXX
504                  */
505                 s = getenv ("flashchecksum");
506                 if (s && (*s == 'y')) {
507                         printf ("  CRC: %08lX",
508                                         crc32 (0,
509                                                    (const unsigned char *) CFG_FLASH_BASE,
510                                                    flash_size)
511                                         );
512                 }
513                 putc ('\n');
514 # else  /* !CFG_FLASH_CHECKSUM */
515                 print_size (flash_size, "\n");
516 # endif /* CFG_FLASH_CHECKSUM */
517         } else {
518                 puts (failed);
519                 hang ();
520         }
521
522         bd->bi_flashstart = CFG_FLASH_BASE;     /* update start of FLASH memory    */
523         bd->bi_flashsize = flash_size;  /* size of FLASH memory (final value) */
524         bd->bi_flashoffset = 0;
525 #else   /* CFG_NO_FLASH */
526         bd->bi_flashsize = 0;
527         bd->bi_flashstart = 0;
528         bd->bi_flashoffset = 0;
529 #endif /* !CFG_NO_FLASH */
530
531         WATCHDOG_RESET ();
532
533         /* initialize higher level parts of CPU like time base and timers */
534         cpu_init_r ();
535
536         WATCHDOG_RESET ();
537
538         /* initialize malloc() area */
539         mem_malloc_init ();
540         malloc_bin_reloc ();
541
542 #ifdef CONFIG_SPI
543 # if !defined(CFG_ENV_IS_IN_EEPROM)
544         spi_init_f ();
545 # endif
546         spi_init_r ();
547 #endif
548
549         /* relocate environment function pointers etc. */
550         env_relocate ();
551
552         /*
553          * Fill in missing fields of bd_info.
554          * We do this here, where we have "normal" access to the
555          * environment; we used to do this still running from ROM,
556          * where had to use getenv_r(), which can be pretty slow when
557          * the environment is in EEPROM.
558          */
559         s = getenv ("ethaddr");
560         for (i = 0; i < 6; ++i) {
561                 bd->bi_enetaddr[i] = s ? simple_strtoul (s, &e, 16) : 0;
562                 if (s)
563                         s = (*e) ? e + 1 : e;
564         }
565
566         /* IP Address */
567         bd->bi_ip_addr = getenv_IPaddr ("ipaddr");
568
569         WATCHDOG_RESET ();
570
571
572         /** leave this here (after malloc(), environment and PCI are working) **/
573         /* Initialize devices */
574         devices_init ();
575
576         /* Initialize the jump table for applications */
577         jumptable_init ();
578
579         /* Initialize the console (after the relocation and devices init) */
580         console_init_r ();
581
582 #if defined(CONFIG_MISC_INIT_R)
583         /* miscellaneous platform dependent initialisations */
584         misc_init_r ();
585 #endif
586
587 #if (CONFIG_COMMANDS & CFG_CMD_KGDB)
588         WATCHDOG_RESET ();
589         puts ("KGDB:  ");
590         kgdb_init ();
591 #endif
592
593         debug ("U-Boot relocated to %08lx\n", dest_addr);
594
595         /*
596          * Enable Interrupts
597          */
598         interrupt_init ();
599
600         /* Must happen after interrupts are initialized since
601          * an irq handler gets installed
602          */
603         timer_init();
604
605 #ifdef CONFIG_SERIAL_SOFTWARE_FIFO
606         serial_buffered_init();
607 #endif
608
609 #ifdef CONFIG_STATUS_LED
610         status_led_set (STATUS_LED_BOOT, STATUS_LED_BLINKING);
611 #endif
612
613         udelay (20);
614
615         set_timer (0);
616
617         /* Insert function pointers now that we have relocated the code */
618
619         /* Initialize from environment */
620         if ((s = getenv ("loadaddr")) != NULL) {
621                 load_addr = simple_strtoul (s, NULL, 16);
622         }
623 #if (CONFIG_COMMANDS & CFG_CMD_NET)
624         if ((s = getenv ("bootfile")) != NULL) {
625                 copy_filename (BootFile, s, sizeof (BootFile));
626         }
627 #endif /* CFG_CMD_NET */
628
629         WATCHDOG_RESET ();
630
631 #if (CONFIG_COMMANDS & CFG_CMD_DOC)
632         WATCHDOG_RESET ();
633         puts ("DOC:   ");
634         doc_init ();
635 #endif
636
637 #if (CONFIG_COMMANDS & CFG_CMD_NAND)
638         WATCHDOG_RESET ();
639         puts ("NAND:  ");
640         nand_init();            /* go init the NAND */
641 #endif
642
643 #if (CONFIG_COMMANDS & CFG_CMD_NET) && defined(FEC_ENET)
644         WATCHDOG_RESET();
645         eth_init(bd);
646 #endif
647
648 #ifdef CONFIG_POST
649         post_run (NULL, POST_RAM | post_bootmode_get(0));
650 #endif
651
652 #ifdef CONFIG_LAST_STAGE_INIT
653         WATCHDOG_RESET ();
654         /*
655          * Some parts can be only initialized if all others (like
656          * Interrupts) are up and running (i.e. the PC-style ISA
657          * keyboard).
658          */
659         last_stage_init ();
660 #endif
661
662 #if (CONFIG_COMMANDS & CFG_CMD_BEDBUG)
663         WATCHDOG_RESET ();
664         bedbug_init ();
665 #endif
666
667 #if defined(CONFIG_PRAM) || defined(CONFIG_LOGBUFFER)
668         /*
669          * Export available size of memory for Linux,
670          * taking into account the protected RAM at top of memory
671          */
672         {
673                 ulong pram;
674                 uchar memsz[32];
675 #ifdef CONFIG_PRAM
676                 char *s;
677
678                 if ((s = getenv ("pram")) != NULL) {
679                         pram = simple_strtoul (s, NULL, 10);
680                 } else {
681                         pram = CONFIG_PRAM;
682                 }
683 #else
684                 pram=0;
685 #endif
686 #ifdef CONFIG_LOGBUFFER
687                 /* Also take the logbuffer into account (pram is in kB) */
688                 pram += (LOGBUFF_LEN+LOGBUFF_OVERHEAD)/1024;
689 #endif
690                 sprintf (memsz, "%ldk", (bd->bi_memsize / 1024) - pram);
691                 setenv ("mem", memsz);
692         }
693 #endif
694
695 #ifdef CONFIG_MODEM_SUPPORT
696  {
697          extern int do_mdm_init;
698          do_mdm_init = gd->do_mdm_init;
699  }
700 #endif
701
702 #ifdef CONFIG_WATCHDOG
703         /* disable watchdog if environment is set */
704         if ((s = getenv ("watchdog")) != NULL) {
705                 if (strncmp (s, "off", 3) == 0) {
706                         WATCHDOG_DISABLE ();
707                 }
708         }
709 #endif /* CONFIG_WATCHDOG*/
710
711
712         /* Initialization complete - start the monitor */
713
714         /* main_loop() can return to retry autoboot, if so just run it again. */
715         for (;;) {
716                 WATCHDOG_RESET ();
717                 main_loop ();
718         }
719
720         /* NOTREACHED - no way out of command loop except booting */
721 }
722
723
724 void hang(void)
725 {
726         puts ("### ERROR ### Please RESET the board ###\n");
727         for (;;);
728 }