Subversion Repositories or1k_old

/*

** bootstrap.c -- Load and launch the Atari Linux kernel

**

** Copyright 1993 by Arjan Knor

**

** This file is subject to the terms and conditions of the GNU General Public

** License.  See the file COPYING in the main directory of this archive

** for more details.

**

** History:

**  10 Dec 1995 BOOTP/TFTP support (Roman)

**      03 Oct 1995 Allow kernel to be loaded to TT ram again (Andreas)

**      11 Jul 1995 Add support for ELF format kernel (Andreas)

**      16 Jun 1995 Adapted to Linux 1.2: kernel always loaded into ST ram

**                  (Andreas)

**      14 Nov 1994 YANML (Yet Another New Memory Layout :-) kernel

**                  start address is KSTART_ADDR + PAGE_SIZE, this

**                  does not need the ugly kludge with

**                  -fwritable-strings (++andreas)

**      09 Sep 1994 Adapted to the new memory layout: All the boot_info entry

**                  mentions all ST-Ram and the mover is located somewhere

**                  in the middle of memory (roman)

**                  Added the default arguments file known from the other

**                  bootstrap version

**      19 Feb 1994 Changed everything so that it works? (rdv)

**      14 Mar 1994 New mini-copy routine used (rdv)

*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <stddef.h>

#include <string.h>

#include <ctype.h>

#include "sysvars.h"

#include <osbind.h>

#include <sys/types.h>

#include <sys/file.h>

/* linux specific include files */

#include <linux/a.out.h>

#include <linux/elf.h>

#include <asm/page.h>

#define _LINUX_TYPES_H          /* Hack to prevent including <linux/types.h> */

#include <asm/bootinfo.h>

/* Atari bootstrap include file */

#include "bootstrap.h"

#define MIN_RAMSIZE     (3)     /* 3 MB */

#define TEMP_STACKSIZE 256

extern char *optarg;

extern int optind;

static void get_default_args( int *argc, char ***argv );

/* This is missing in <unistd.h> */

extern int sync (void);

struct bootinfo bi;

u_long *cookiejar;

u_long userstk;

/* getcookie -- function to get the value of the given cookie. */

static int getcookie(char *cookie, u_long *value)

{

    int i = 0;

    while(cookiejar[i] != 0L) {

        if(cookiejar[i] == *(u_long *)cookie) {

            *value = cookiejar[i + 1];

            return 1;

        }

        i += 2;

    }

    return -1;

}

static void usage(void)

{

    fprintf(stderr, "Usage:\n"

            "\tbootstrap [-dst] [-k kernel_executable] [-r ramdisk_file]"

            " [option...]\n");

    exit(EXIT_FAILURE);

}

/*

 * Copy the kernel and the ramdisk to their final resting places.

 *

 * I assume that the kernel data and the ramdisk reside somewhere

 * in the middle of the memory.

 *

 * This program itself should be somewhere in the first 4096 bytes of memory

 * where the kernel never will be. In this way it can never be overwritten

 * by itself.

 *

 * At this point the registers have:

 * a0: the start of the final kernel

 * a1: the start of the current kernel

 * a2: the end of the final ramdisk

 * a3: the end of the current ramdisk

 * d0: the kernel size

 * d1: the ramdisk size

 */

asm ("

.text

.globl _copyall, _copyallend

_copyall:

        movel   a0,a4           /* save the start of the kernel for booting */

1:      movel   a1@+,a0@+       /* copy the kernel starting at the beginning */

        subql   #4,d0

        jcc     1b

        tstl    d1

        beq             3f

2:      movel   a3@-,a2@-       /* copy the ramdisk starting at the end */

        subql   #4,d1

        jcc     2b

3:      jmp     a4@             /* jump to the start of the kernel */

_copyallend:

");

extern char copyall, copyallend;

/* Test for a Medusa: This is the only machine on which address 0 is

 * writeable!

 * ...err! On the Afterburner040 (for the Falcon) it's the same... So we do

 * another test with 0x00ff82fe, that gives a bus error on the Falcon, but is

 * in the range where the Medusa always asserts DTACK.

 */

int test_medusa( void )

{       int             rv = 0;

        __asm__ __volatile__

                ( "movel        0x8,a0\n\t"

                  "movel        sp,a1\n\t"

                  "moveb        0x0,d1\n\t"

                  "movel        #Lberr,0x8\n\t"

                  "moveq        #0,%0\n\t"

                  "clrb         0x0\n\t"

                  "nop          \n\t"

                  "moveb        d1,0x0\n\t"

                  "nop          \n\t"

                  "tstb         0x00ff82fe\n\t"

                  "nop          \n\t"

                  "moveq        #1,%0\n"

                "Lberr:\t"

                  "movel        a1,sp\n\t"

                  "movel        a0,0x8"

                  : "=d" (rv)

                  : /* no inputs */

                  : "d1", "a0", "a1", "memory" );

        return( rv );

}

void get_medusa_bank_sizes( u_long *bank1, u_long *bank2 )

{       static u_long   save_addr;

        u_long                  test_base, saved_contents[16];

#define TESTADDR(i)     (*((u_long *)((char *)test_base + i*8*MB)))

#define TESTPAT         0x12345678

        unsigned short  oldflags;

        int                             i;

        /* This ensures at least that none of the test addresses conflicts

         * with the test code itself */

        test_base = ((unsigned long)&save_addr & 0x007fffff) | 0x20000000;

        *bank1 = *bank2 = 0;

        /* Interrupts must be disabled because arbitrary addresses may be

         * temporarily overwritten, even code of an interrupt handler */

        __asm__ __volatile__ ( "movew sr,%0; oriw #0x700,sr" : "=g" (oldflags) : );

        disable_cache();

        /* save contents of the test addresses */

        for( i = 0; i < 16; ++i )

                saved_contents[i] = TESTADDR(i);

        /* write 0s into all test addresses */

        for( i = 0; i < 16; ++i )

                TESTADDR(i) = 0;

        /* test for bank 1 */

#if 0

        /* This is Freddi's original test, but it didn't work. */

        TESTADDR(0) = TESTADDR(1) = TESTPAT;

        if (TESTADDR(1) == TESTPAT) {

                if (TESTADDR(2) == TESTPAT)

                        *bank1 = 8*MB;

                else if (TESTADDR(3) == TESTPAT)

                        *bank1 = 16*MB;

                else

                        *bank1 = 32*MB;

        }

        else {

                if (TESTADDR(2) == TESTPAT)

                        *bank1 = 0;

                else

                        *bank1 = 16*MB;

        }

#else

        TESTADDR(0) = TESTPAT;

        if (TESTADDR(1) == TESTPAT)

                *bank1 = 8*MB;

        else if (TESTADDR(2) == TESTPAT)

                *bank1 = 16*MB;

        else if (TESTADDR(4) == TESTPAT)

                *bank1 = 32*MB;

        else

                *bank1 = 64*MB;

#endif

        /* test for bank2 */

        if (TESTADDR(8) != 0)

                *bank2 = 0;

        else {

                TESTADDR(8) = TESTPAT;

                if (TESTADDR(9) != 0) {

                        if (TESTADDR(10) == TESTPAT)

                                *bank2 = 8*MB;

                        else

                                *bank2 = 32*MB;

                }

                else {

                        TESTADDR(9) = TESTPAT;

                        if (TESTADDR(10) == TESTPAT)

                                *bank2 = 16*MB;

                        else

                                *bank2 = 64*MB;

                }

        }

        /* restore contents of the test addresses and restore interrupt mask */

        for( i = 0; i < 16; ++i )

                TESTADDR(i) = saved_contents[i];

        __asm__ __volatile__ ( "movew %0,sr" : : "g" (oldflags) );

}

#undef TESTADDR

#undef TESTPAT

#ifdef USE_BOOTP

# include "bootp.h"

#else

# define kread  read

# define klseek lseek

# define kclose close

#endif

/* ++andreas: this must be inline due to Super */

static inline void boot_exit (int) __attribute__ ((noreturn));

static inline void boot_exit(int status)

{

    /* first go back to user mode */

    (void)Super(userstk);

        getchar();

    exit(status);

}

int main(int argc, char *argv[])

{

    int debugflag = 0, ch, kfd, rfd = -1, i, ignore_ttram = 0;

    int load_to_stram = 0;

    char *ramdisk_name, *kernel_name, *memptr;

    u_long ST_ramsize, TT_ramsize, memreq;

    u_long cpu_type, fpu_type, mch_type, mint;

    struct exec kexec;

    int elf_kernel = 0;

    Elf32_Ehdr kexec_elf;

    Elf32_Phdr *kernel_phdrs = NULL;

    u_long start_mem, mem_size, rd_size, text_offset = 0, kernel_size;

#ifdef USE_BOOTP

    int prefer_bootp = 1, kname_set = 0;

#endif

    ramdisk_name = NULL;

    kernel_name = "vmlinux";

    /* print the startup message */

    puts("\fLinux/68k Atari Bootstrap version 1.6"

#ifdef USE_BOOTP

         " (with BOOTP)"

#endif

         );

    puts("Copyright 1993,1994 by Arjan Knor, Robert de Vries, Roman Hodek, Andreas Schwab\n");

        /* ++roman: If no arguments on the command line, read them from

         * file */

        if (argc == 1)

                get_default_args( &argc, &argv );

    /* machine is Atari */

    bi.machtype = MACH_ATARI;

    /* check arguments */

#ifdef USE_BOOTP

    while ((ch = getopt(argc, argv, "bdtsk:r:")) != EOF)

#else

    while ((ch = getopt(argc, argv, "dtsk:r:")) != EOF)

#endif

        switch (ch) {

          case 'd':

            debugflag = 1;

            break;

          case 't':

            ignore_ttram = 1;

            break;

          case 's':

            load_to_stram = 1;

            break;

          case 'k':

            kernel_name = optarg;

#ifdef USE_BOOTP

            kname_set = 1;

#endif

            break;

          case 'r':

            ramdisk_name = optarg;

            break;

#ifdef USE_BOOTP

          case 'b':

            prefer_bootp = 1;

            break;

#endif

          case '?':

          default:

            usage();

        }

    argc -= optind;

    argv += optind;

    /* We have to access some system variables to get

     * the information we need, so we must switch to

     * supervisor mode first.

     */

    userstk = Super(0L);

    /* get the info we need from the cookie-jar */

    cookiejar = *_p_cookies;

    if(cookiejar == 0L) {

        /* if we find no cookies, it's probably an ST */

        fprintf(stderr, "Error: No cookiejar found. Is this an ST?\n");

        boot_exit(EXIT_FAILURE);

    }

    /* Exit if MiNT/MultiTOS is running.  */

    if(getcookie("MiNT", &mint) != -1)

    {

        puts("Warning: MiNT is running\n");

#if 0

        puts("Linux cannot be started when MiNT is running. Aborting...\n");

        boot_exit(EXIT_FAILURE);

#endif

    }

    /* get _CPU, _FPU and _MCH */

    getcookie("_CPU", &cpu_type);

    getcookie("_FPU", &fpu_type);

    getcookie("_MCH", &mch_type);

    /* check if we are on a 68030/40 with FPU */

    if ((cpu_type != 30 && cpu_type != 40 && cpu_type != 60) ||

                (fpu_type >> 16) < 2)

    {

        puts("Machine type currently not supported. Aborting...");

        boot_exit(EXIT_FAILURE);

    }

    switch(cpu_type) {

      case  0:

      case 10: break;

      case 20: bi.cputype = CPU_68020; break;

      case 30: bi.cputype = CPU_68030; break;

      case 40: bi.cputype = CPU_68040; break;

      case 60: bi.cputype = CPU_68060; break;

      default:

        fprintf(stderr, "Error: Unknown CPU type. Aborting...\n");

        boot_exit(EXIT_FAILURE);

        break;

    }

    printf("CPU: %ld; ", cpu_type + 68000);

    printf("FPU: ");

    /* check for FPU; in case of a '040 or '060, don't look at _FPU itself,

     * some software may set it to wrong values (68882 or the like) */

        if (cpu_type == 40) {

                bi.cputype |= FPU_68040;

                puts( "68040\n" );

        }

        else if (cpu_type == 60) {

                bi.cputype |= FPU_68060;

                puts( "68060\n" );

        }

        else {

                switch ((fpu_type >> 16) & 6) {

                  case 0:

                        puts("not present\n");

                        break;

                  case 2:

                        /* try to determine real type */

                        if (fpu_idle_frame_size () != 0x18)

                                goto m68882;

                        /* fall through */

                  case 4:

                        bi.cputype |= FPU_68881;

                        puts("68881\n");

                        break;

                  case 6:

                  m68882:

                        bi.cputype |= FPU_68882;

                        puts("68882\n");

                        break;

                  default:

                        puts("Unknown FPU type. Assuming no FPU.");

                        break;

                }

        }

    memset(&bi.bi_atari.hw_present, 0, sizeof(bi.bi_atari.hw_present));

    /* Get the amounts of ST- and TT-RAM. */

    /* The size must be a multiple of 1MB. */

    i = 0;

    if (!test_medusa()) {

        struct {

                unsigned short version;   /* version - currently 1 */

                unsigned long fr_start; /* start addr FastRAM */

                unsigned long fr_len;   /* length FastRAM */

        } *magn_cookie;

        struct {

                unsigned long version;

                unsigned long fr_start; /* start addr */

                unsigned long fr_len;   /* length */

        } *fx_cookie;

        TT_ramsize = 0;

        if (!ignore_ttram) {

            /* "Original" or properly emulated TT-Ram */

            if (*ramtop) {

                /* the 'ramtop' variable at 0x05a4 is not

                 * officially documented. We use it anyway

                 * because it is the only way to get the TTram size.

                 * (It is zero if there is no TTram.)

                 */

                bi.memory[i].addr = TT_RAM_BASE;

                bi.memory[i].size = (*ramtop - TT_RAM_BASE) & ~(MB - 1);

                TT_ramsize = bi.memory[i].size / MB;

                i++;

                printf("TT-RAM: %ld Mb; ", TT_ramsize);

            }

            /* test for MAGNUM alternate RAM

             * added 26.9.1995 M. Schwingen, rincewind@discworld.oche.de

             */

            if (getcookie("MAGN", (u_long *)&magn_cookie) != -1) {

                bi.memory[i].addr = magn_cookie->fr_start;

                bi.memory[i].size = magn_cookie->fr_len & ~(MB - 1);

                TT_ramsize += bi.memory[i].size / MB;

                printf("MAGNUM alternate RAM: %ld Mb; ", bi.memory[i].size/MB);

                i++;

            }

            /* BlowUps FX */

            if (getcookie("BPFX", (u_long *)&fx_cookie) != -1 && fx_cookie) {

                /* if fx is set (cookie call above),

                 * we assume that BlowUps FX-card

                 * is installed. (Nat!)

                 */

                bi.memory[i].addr = fx_cookie->fr_start;

                bi.memory[i].size = fx_cookie->fr_len & ~(MB - 1);

                printf("FX alternate RAM: %ld Mb; ", bi.memory[i].size/MB);

                i++;

            }

        }

        bi.memory[i].addr = 0;

        bi.memory[i].size = *phystop & ~(MB - 1);

        ST_ramsize = bi.memory[i].size / MB;

        i++;

        printf("ST-RAM: %ld Mb\n", ST_ramsize );

        bi.num_memory = i;

        if (load_to_stram && i > 1) {

            /* Put ST-RAM first in the list of mem blocks */

            struct mem_info temp = bi.memory[i - 1];

            bi.memory[i - 1] = bi.memory[0];

            bi.memory[0] = temp;

        }

    }

    else {

        u_long  bank1, bank2, medusa_st_ram;

        get_medusa_bank_sizes( &bank1, &bank2 );

        medusa_st_ram = *phystop & ~(MB - 1);

        bank1 -= medusa_st_ram;

        TT_ramsize = 0;

        bi.memory[i].addr = 0;

        bi.memory[i].size = medusa_st_ram;

        ST_ramsize = bi.memory[i].size / MB;

        i++;

        printf("Medusa pseudo ST-RAM from bank 1: %ld Mb; ", ST_ramsize );

        if (!ignore_ttram && bank1 > 0) {

            bi.memory[i].addr = 0x20000000 + medusa_st_ram;

            bi.memory[i].size = bank1;

            TT_ramsize += bank1;

            i++;

            printf("TT-RAM bank 1: %ld Mb; ", bank1/MB );

        }

        if (!ignore_ttram && bank2 > 0) {

            bi.memory[i].addr = 0x24000000;

            bi.memory[i].size = bank2;

            TT_ramsize += bank2;

            i++;

            printf("TT-RAM bank 2: %ld Mb; ", bank2/MB );

        }

        bi.num_memory = i;

        printf("\n");

    }

    /* verify that there is enough RAM; ST- and TT-RAM combined */

    if (ST_ramsize + TT_ramsize < MIN_RAMSIZE) {

        puts("Not enough RAM. Aborting...");

        boot_exit(10);

    }

#if 0   

    /* Get language/keyboard info */

    /* TODO: do we need this ? */

    /* Could be used to auto-select keyboard map later on. (rdv) */

    if (getcookie("_AKP",&language) == -1)

    {

        /* Get the language info from the OS-header */

        os_header = *_sysbase;

        os_header = os_header->os_beg;

        lang = (os_header->os_conf) >> 1;

        printf("Language: ");

        switch(lang) {

          case HOL: puts("Dutch"); break; /* Own country first :-) */

          case USA: puts("American"); break;

          case SWG: puts("Switzerland (German)"); break;

          case FRG: puts("German"); break;

          case FRA: puts("French"); break;

          case SWF: puts("Switzerland (French)"); break;

          case UK:  puts("English"); break;

          case SPA: puts("Spanish"); break;

          case ITA: puts("Italian"); break;

          case SWE: puts("Swedish"); break;

          case TUR: puts("Turkey"); break;

          case FIN: puts("Finnish"); break;

          case NOR: puts("Norwegian"); break;

          case DEN: puts("Danish"); break;

          case SAU: puts("Saudi-Arabian"); break;

          default:  puts("Unknown"); break;

        }

    }

    else

    {

        printf("Language: ");

        switch(language & 0x0F)

        {

          case 1: printf("German "); break;

          case 2: printf("French "); break;

          case 4: printf("Spanish "); break;

          case 5: printf("Italian "); break;

          case 7: printf("Swiss French "); break;

          case 8: printf("Swiss German "); break;

          default: printf("English ");

        }

        printf("Keyboard type :");

        switch(language >> 8)

        {

          case 1: printf("German "); break;

          case 2: printf("French "); break;

          case 4: printf("Spanish "); break;

          case 5: printf("Italian "); break;

          case 7: printf("Swiss French "); break;

          case 8: printf("Swiss German "); break;

          default: printf("English ");

        }

        printf("\n");

    }

#endif

    /* Pass contents of the _MCH cookie to the kernel */

    bi.bi_atari.mch_cookie = mch_type;

    /*

     * Copy command line options into the kernel command line.

     */

    i = 0;

    while (argc--) {

        if ((i+strlen(*argv)+1) < CL_SIZE) {

            i += strlen(*argv) + 1;

            if (bi.command_line[0])

                strcat (bi.command_line, " ");

            strcat (bi.command_line, *argv++);

        }

    }

    printf ("Command line is '%s'\n", bi.command_line);

    start_mem = bi.memory[0].addr;

    mem_size = bi.memory[0].size;

    /* tell us where the kernel will go */

    printf("\nThe kernel will be located at 0x%08lx\n", start_mem);

#ifdef TEST

    /*

    ** Temporary exit point for testing

    */

    boot_exit(-1);

#endif /* TEST */

#ifdef USE_BOOTP

    kfd = -1;

    if (prefer_bootp) {

        /* First try to get a remote kernel, then use a local kernel (if

         * present) */

        if (get_remote_kernel( kname_set ? kernel_name : NULL ) < 0) {

            printf( "\nremote boot failed; trying local kernel\n" );

            if ((kfd = open (kernel_name, O_RDONLY)) == -1) {

                fprintf (stderr, "Unable to open kernel file %s\n",

                         kernel_name);

                boot_exit (EXIT_FAILURE);

            }

        }

    }

    else {

        /* Try BOOTP if local kernel cannot be opened */

        if ((kfd = open (kernel_name, O_RDONLY)) == -1) {

            printf( "\nlocal kernel failed; trying remote boot\n" );

            if (get_remote_kernel( kname_set ? kernel_name : NULL ) < 0) {