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