/*
 * $NetBSD: main.c,v 1.32 2021/12/05 08:09:30 msaitoh Exp $
 *
 *
 * Copyright (c) 1996,1999 Ignatios Souvatzis
 * Copyright (c) 1994 Michael L. Hitch
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <sys/cdefs.h>
#include <sys/reboot.h>
#include <sys/types.h>

#include <sys/exec_aout.h>

#include <amiga/cfdev.h>
#include <amiga/memlist.h>
#include <include/cpu.h>

#include <saerrno.h>
#include <lib/libsa/stand.h>

#include "libstubs.h"
#include "samachdep.h"
#include "loadfile.h"

#undef AOUT_LDPGSZ
#define AOUT_LDPGSZ 8192
#define __PGSZ 8192

#define DRACOREVISION   (*(u_int8_t *)0x02000009)
#define DRACOMMUMARGIN  0x200000
#define DRACOZ2OFFSET   0x3000000
#define DRACOZ2MAX      0x1000000

#define EXECMIN 36

/*
 * vers.c (generated by newvers.sh)
 */
extern const char bootprog_rev[];

void startit(void *, u_long, u_long, void *, u_long, u_long, int, void *,
             int, int, u_long, u_long, u_long, int);
int get_cpuid(u_int32_t *);
#ifdef PPCBOOTER
u_int16_t kickstart[];
size_t kicksize;
#else
void startit_end(void);
#endif

/*
 * Kernel startup interface version
 *      1:      first version of loadbsd
 *      2:      needs esym location passed in a4
 *      3:      load kernel image into fastmem rather than chipmem
 *      MAX:    highest version with backward compatibility.
 */

#define KERNEL_STARTUP_VERSION          3
#define KERNEL_STARTUP_VERSION_MAX      9

static long get_number(char **);

extern char default_command[];

int
pain(void *aio, void *cons)
{
        char linebuf[128];
        char    *kernel_name = default_command;
        char    *path = default_command;
        int     boothowto = RB_AUTOBOOT;
        u_int32_t cpuid = 0;
        int     amiga_flags = 0;
        u_int32_t I_flag = 0;
        int     k_flag = 0;
        int     p_flag = 0;
        int     m_value = 0;
        int     S_flag = 0;
        /* int  t_flag = 0; */

        u_int32_t fmem = 0x0;
        int     fmemsz = 0x0;
        int     cmemsz = 0x0;
        int     eclock = SysBase->EClockFreq;
        /* int  skip_chipmem = 0; */

        void (*start_it)(void *, u_long, u_long, void *, u_long, u_long, int,
            void *, int, int, u_long, u_long, u_long, int);

        void *kp;
        u_int16_t *kvers;
        int     ksize;
        void    *esym = 0;
        int32_t *nkcd;
        struct cfdev *cd, *kcd;
        struct boot_memseg *kmemseg;
        struct boot_memseg *memseg;
        struct MemHead *mh;
        u_int32_t from, size, vfrom, vsize;
        int contflag, mapped1to1;
        int8_t mempri;

        int ncd, nseg;
        char c;

        u_long marks[MARK_MAX];

        extern u_int16_t timelimit;

        extern u_int32_t aio_base;

        xdinit(aio);

        if (consinit(cons))
                return(1);

        /*
         * we need V36 for: EClock, RDB Bootblocks, CacheClearU
         */

        if (SysBase->LibNode.Version < EXECMIN) {
                printf("Exec V%ld, need V%ld\n",
                    (long)SysBase->LibNode.Version, (long)EXECMIN);
                goto out;
        }

/*
 * XXX Do this differently;  default boot will attempt to load a list of
 * XXX kernels until one of them succeeds.
 */
        timelimit = 3;
again:
#ifdef PPCBOOTER
        printf("\nNetBSD/AmigaPPC " NETBSD_VERS " Bootstrap, Revision %s\n",
            bootprog_rev);
#else
        printf("\nNetBSD/Amiga " NETBSD_VERS " Bootstrap, Revision %s\n",
            bootprog_rev);
#endif
        printf("\n");
        printf("Boot: [%s] ", kernel_name);

        kgets(linebuf, sizeof(linebuf));

        if (*linebuf == 'q')
                return 1;

        if (*linebuf)
                path = linebuf;

        /*
         * parse boot command for path name and process any options
         */
        while ((c = *path)) {
                while (c == ' ')
                        c = *++path;
                if (c == '-') {
                        while ((c = *++path) && c != ' ') {
                                switch (c) {
                                case 'a':       /* multi-user state */
                                        boothowto &= ~RB_SINGLE;
                                        break;
                                case 'b':       /* ask for root device */
                                        boothowto |= RB_ASKNAME;
                                        break;
                                case 'c':       /* force machine model */
                                        cpuid = get_number(&path) << 16;
                                        break;
                                case 'k':       /* Reserve first 4M fastmem */
                                        k_flag++;
                                        break;
                                case 'm':       /* Force fastmem size */
                                        m_value = get_number(&path) * 1024;
                                        break;
                                case 'n':       /* non-contiguous memory */
                                        amiga_flags |=
                                            (get_number(&path) & 3) << 1;
                                        break;
                                case 'p':       /* Select fastmem by priority */
                                        p_flag = 1;
                                        break;
                                case 'q':
                                        boothowto |= AB_QUIET;
                                        break;
                                case 's':       /* single-user state */
                                        boothowto |= RB_SINGLE;
                                        break;
                                case 't':       /* test flag */
                                        /* t_flag = 1; */
                                        break;
                                case 'v':
                                        boothowto |= AB_VERBOSE;
                                        break;
                                case 'A':       /* enable AGA modes */
                                        amiga_flags |= 1;
                                        break;
                                case 'C':       /* Serial Console */
                                        amiga_flags |= (1 << 3);
                                        break;
                                case 'D':       /* enter Debugger */
                                        boothowto |= RB_KDB;
                                        break;
                                case 'I':       /* inhibit sync negotiation */
                                        I_flag = get_number(&path);
                                        break;
                                case 'K':       /* remove 1st 4MB fastmem */
                                        break;
                                case 'S':       /* include debug symbols */
                                        S_flag = 1;
                                        break;
                                }
                        }
                } else {
/* XXX Handle kernel_name differently */
                        kernel_name = path;
                        while ((c = *++path) && c != ' ')
                                ;
                        if (c)
                                *path++ = 0;
                }
        }
/* XXX Handle kernel_name differently */
        while ((c = *kernel_name) && c == ' ')
                ++kernel_name;
        path = kernel_name;
        while ((c = *path) && c != ' ')
                ++path;
        if (c)
                *path = 0;

        if (get_cpuid(&cpuid))
                goto out;

        ExpansionBase = OpenLibrary("expansion.library", 0);
        if (!ExpansionBase) {
                printf("can't open %s\n", "expansion.library");
                return 1;
        }

        for (ncd=0, cd=0; (cd = FindConfigDev(cd, -1, -1)); ncd++)
                /* nothing */;

        /* find memory list */

        memseg = (struct boot_memseg *)alloc(16*sizeof(struct boot_memseg));

        /* Forbid(); */

        nseg = 0;
        mh = SysBase->MemLst;
        vfrom = mh->Lower & -__PGSZ;
        vsize = (mh->Upper & -__PGSZ) - vfrom;
        contflag = mapped1to1 = 0;
        mempri = -128;

        do {
                size = vsize;

                if (SysBase->LibNode.Version > 36) {
                        from = CachePreDMA(vfrom, &size, contflag);
                        contflag = DMAF_Continue;
                        mapped1to1 = (from == vfrom);
                        vsize -= size;
                        vfrom += size;
                } else {
                        from = vfrom;
                        mapped1to1 = 1;
                        vsize = 0;
                }

#ifdef DEBUG_MEMORY_LIST
                printf("%lx %lx %lx %ld/%lx %lx\n",
                        (long)from, (long)size,
                        (long)mh->Attribs, (long)mh->Pri,
                        (long)vfrom, (long)vsize);
#endif
                /* Insert The Evergrowing Kludge List Here: */

                /* a) dont load kernel over DraCo MMU table */

                if (((cpuid >> 24) == 0x7D) &&
                    ((from & -DRACOMMUMARGIN) == 0x40000000) &&
                    (size >= DRACOMMUMARGIN)) {

                        memseg[nseg].ms_start = from & -DRACOMMUMARGIN;
                        memseg[nseg].ms_size = DRACOMMUMARGIN;
                        memseg[nseg].ms_attrib = mh->Attribs;
                        memseg[nseg].ms_pri = mh->Pri;

                        size -= DRACOMMUMARGIN - (from & (DRACOMMUMARGIN - 1));
                        from += DRACOMMUMARGIN - (from & (DRACOMMUMARGIN - 1));
                        ++nseg;
                }

                if ((mh->Attribs & (MEMF_CHIP|MEMF_FAST)) == MEMF_CHIP) {
                        size += from;
                        cmemsz = size;
                        from = 0;
                } else if (mapped1to1 && ((!p_flag && fmemsz < size) ||
                    (p_flag && (mempri < mh->Pri ||
                    (mempri == mh->Pri && fmemsz < size))))) {
                        fmem = from;
                        fmemsz = size;
                        mempri = mh->Pri;
                }

                memseg[nseg].ms_start = from;
                memseg[nseg].ms_size = size;
                memseg[nseg].ms_attrib = mh->Attribs;
                memseg[nseg].ms_pri = mh->Pri;

                if (vsize == 0) {
                        mh = mh->next;
                        contflag = 0;
                        if (mh->next) {
                                vfrom = mh->Lower & -__PGSZ;
                                vsize = (mh->Upper & -__PGSZ) - vfrom;
                        }
                }
        } while ((++nseg <= 16) && vsize);

        /* Permit(); */

        if (k_flag) {
                fmem += 4*1024*1024;
                fmemsz -= 4*1024*1024;
        }
        if (m_value && m_value < fmemsz)
                fmemsz = m_value;

/* XXX Loop through list of kernels */
        printf("Loading %s: ", kernel_name);
/*
 * XXX Call loadfile with COUNT* options to get size
 * XXX Allocate memory for kernel + additional data
 * XXX Call loadfile with LOAD* options to load text/data/symbols
 */
        marks[MARK_START] = 0;
        if (loadfile(kernel_name, marks,
            COUNT_TEXT|COUNT_TEXTA|COUNT_DATA|COUNT_BSS |
            (S_flag ? (COUNT_SYM|COUNT_HDR) : 0)) == -1) {
                goto err;
        }
        ksize = ((marks[MARK_END] + 3) & ~3)
            + sizeof(*nkcd) + ncd*sizeof(*cd)
            + sizeof(*nkcd) + nseg * sizeof(struct boot_memseg);

#ifdef PPCBOOTER
        kp = alloc(ksize);
#else
        kp = alloc(ksize + 256 + ((u_char *)startit_end - (u_char *)startit));
#endif
        if (kp == 0) {
                errno = ENOMEM;
                goto err;
        }

        marks[MARK_START] = (u_long)kp;
        if (loadfile(kernel_name, marks,
            LOAD_TEXT|LOAD_TEXTA|LOAD_DATA|LOAD_BSS|
            (S_flag ? (LOAD_SYM|LOAD_HDR) : 0)) == -1) {
printf("Kernel load failed\n");
                goto err;
        }
        marks[MARK_END] = (marks[MARK_END] + 3) & ~3;
        nkcd = (int *)marks[MARK_END];
        if (S_flag)
                esym = (void*)(marks[MARK_END] - marks[MARK_START]);
/* #ifndef PPCBOOTER*/
        kvers = (u_short *)(marks[MARK_ENTRY] - 2);

        if (*kvers > KERNEL_STARTUP_VERSION_MAX && *kvers != 0x4e73) {
                printf("\nnewer bootblock required: %ld\n", (long)*kvers);
                goto freeall;
        }
        if (*kvers < KERNEL_STARTUP_VERSION || *kvers == 0x4e73) {
                printf("\nkernel too old for bootblock\n");
                goto freeall;
        }
#if 0
        if (*kvers > KERNEL_STARTUP_VERSION)
                printf("\nKernel V%ld newer than bootblock V%ld\n",
                    (long)*kvers, (long)KERNEL_STARTUP_VERSION);
#endif
        if (marks[MARK_NSYM] && (*kvers == 0x4e73 || *kvers <= 1)) {
                nkcd = (int *)marks[MARK_SYM];
                esym = 0;
printf("Suppressing %ld kernel symbols\n", marks[MARK_NSYM]);
                timelimit = 60;
                (void)getchar();
        }
        /* version checks */
        putchar('\n');

        *nkcd = ncd;
        kcd = (struct cfdev *)(nkcd + 1);

        while ((cd = FindConfigDev(cd, -1, -1))) {
                *kcd = *cd;
#ifndef PPCBOOTER
                if (((cpuid >> 24) == 0x7D) &&
                    ((u_long)kcd->addr < 0x1000000)) {
                        kcd->addr = (char *)kcd->addr + 0x3000000;
                }
#endif
                ++kcd;
        }

        nkcd = (int32_t *)kcd;
        *nkcd = nseg;

        kmemseg = (struct boot_memseg *)(nkcd + 1);

        while (nseg-- > 0)
                *kmemseg++ = *memseg++;

#ifdef PPCBOOTER
        /*
         * we use the ppc starter...
         */
        start_it = startit;
#else
        /*
         * Copy startup code to end of kernel image and set start_it.
         */
        memcpy((char *)kp + ksize + 256, (char *)startit,
            (char *)startit_end - (char *)startit);
        CacheClearU();
        start_it = (void *)((char *)kp + ksize + 256);
#endif
        printf("*** Loading from %08lx to Fastmem %08lx ***\n",
            (u_long)kp, (u_long)fmem);
        /* sleep(2); */

#if 0
        printf("would start(kp=0x%lx, ksize=%ld, entry=0x%lx,\n"
                "fmem=0x%lx, fmemsz=%ld, cmemsz=%ld\n"
                "boothow=0x%lx, esym=0x%lx, cpuid=0x%lx, eclock=%ld\n"
                "amigaflags=0x%lx, I_flags=0x%lx, ok?\n",
            (u_long)kp, (u_long)ksize, marks[MARK_ENTRY] - marks[MARK_START],
            (u_long)fmem, (u_long)fmemsz, (u_long)cmemsz,
            (u_long)boothowto, (u_long)esym, (u_long)cpuid, (u_long)eclock,
            (u_long)amiga_flags, (u_long)I_flag);
        timelimit = 60;
        (void)getchar();
#endif
#ifdef DEBUG_MEMORY_LIST
        timelimit = 0;
#else
        timelimit = 2;
#endif
        (void)getchar();

#ifdef PPCBOOTER
        startit
#else
        start_it
#endif
                (kp, ksize, marks[MARK_ENTRY] - marks[MARK_START], (void *)fmem, fmemsz, cmemsz,
            boothowto, esym, cpuid, eclock, amiga_flags, I_flag,
            aio_base >> 9, 1);
        /*NOTREACHED*/

freeall:
        dealloc(kp, ksize);
err:
        printf("\nError %ld\n", (long)errno);
        goto again;
out:
        timelimit = 10;
        (void)getchar();
        return 1;
}

static
long get_number(char **ptr)
{
        long value = 0;
        int base = 10;
        char *p = *ptr;
        char c;
        char sign = 0;

        c = *++p;
        while (c == ' ')
                c = *++p;
        if (c == '-') {
                sign = -1;
                c = *++p;
        }
        if (c == '$') {
                base = 16;
                c = *++p;
        } else if (c == '0') {
                c = *++p;
                if ((c & 0xdf) == 'X') {
                        base = 16;
                        c = *++p;
                }
        }
        while (c) {
                if (c >= '0' && c <= '9')
                        c -= '0';
                else {
                        c = (c & 0xdf) - 'A' + 10;
                        if (base != 16 || c < 10 || c > 15)
                                break;
                }
                value = value * base + c;
                c = *++p;
        }
        *ptr = p - 1;
#ifdef TEST
        fprintf(stderr, "get_number: got %c0x%x",
            sign ? '-' : '+', value);
#endif
        return (sign ? -value : value);
}

/*
 * Try to determine the machine ID by searching the resident module list
 * for modules only present on specific machines.  (Thanks, Bill!)
 */

int
get_cpuid(u_int32_t *cpuid)
{
        uint8_t alicerev;

        alicerev = *((uint8_t *)0xdff004) & 0x6f;
        *cpuid |= SysBase->AttnFlags;   /* get FPU and CPU flags */

        if (*cpuid & 0xffff0000) {
                if ((*cpuid >> 24) == 0x7D)
                        return 0;

                switch (*cpuid >> 16) {
                case 500:
                case 600:
                case 1000:
                case 1200:
                case 2000:
                case 3000:
                case 4000:
                        return 0;
                default:
                        printf("Amiga %ld ???\n",
                            (long)(*cpuid >> 16));
                        return(1);
                }
        }
        if (FindResident("A4000 Bonus") || FindResident("A4000 bonus")
            || FindResident("A1000 Bonus"))
                *cpuid |= 4000 << 16;
        else if (FindResident("A3000 Bonus") || FindResident("A3000 bonus")
            || (SysBase->LibNode.Version == 36))
                *cpuid |= 3000 << 16;
        else if (OpenResource("card.resource")) {
                if (alicerev == 0x22 || alicerev == 0x23)
                        *cpuid |= 1200 << 16;   /* AGA + PCMCIA = A1200 */
                else
                        *cpuid |= 600 << 16;    /* noAGA + PCMCIA = A600 */
        } else if (OpenResource("draco.resource")) {
                *cpuid |= (32000 | DRACOREVISION) << 16;
        }
        /*
         * Nothing found, it's probably an A2000 or A500
         */
        if ((*cpuid >> 16) == 0)
                *cpuid |= 2000 << 16;

        return 0;
}