/*      $NetBSD: boot.c,v 1.35 2017/09/15 13:25:34 martin Exp $ */

/*
 * Copyright (c) 1997, 1999 Eduardo E. Horvath.  All rights reserved.
 * Copyright (c) 1997 Jason R. Thorpe.  All rights reserved.
 * Copyright (C) 1995, 1996 Wolfgang Solfrank.
 * Copyright (C) 1995, 1996 TooLs GmbH.
 * All rights reserved.
 *
 * ELF support derived from NetBSD/alpha's boot loader, written
 * by Christopher G. Demetriou.
 *
 * 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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by TooLs GmbH.
 * 4. The name of TooLs GmbH may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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.
 */

/*
 * First try for the boot code
 *
 * Input syntax is:
 *      [promdev[{:|,}partition]]/[filename] [flags]
 */

#include <lib/libsa/stand.h>
#include <lib/libsa/bootcfg.h>
#include <lib/libsa/loadfile.h>
#include <lib/libkern/libkern.h>

#include <sys/param.h>
#include <sys/reboot.h>
#include <sys/disklabel.h>
#include <sys/boot_flag.h>

#include <machine/cpu.h>
#include <machine/promlib.h>
#include <machine/bootinfo.h>
#include <sparc/stand/common/isfloppy.h>

#include "boot.h"
#include "ofdev.h"
#include "openfirm.h"


#define COMPAT_BOOT(marks)      (marks[MARK_START] == marks[MARK_ENTRY])


typedef void (*entry_t)(long o0, long bootargs, long bootsize, long o3,
                        long ofw);

/*
 * Boot device is derived from ROM provided information, or if there is none,
 * this list is used in sequence, to find a kernel.
 */
const char *kernelnames[] = {
        "netbsd",
        "netbsd.gz",
        "netbsd.old",
        "netbsd.old.gz",
        "onetbsd",
        "onetbsd.gz",
        "vmunix ",
#ifdef notyet
        "netbsd.pl ",
        "netbsd.pl.gz ",
        "netbsd.el ",
        "netbsd.el.gz ",
#endif
        NULL
};

char bootdev[PROM_MAX_PATH];
bool root_fs_quickseekable = true;      /* unset for tftp boots */
static bool bootinfo_pass_bootdev = false;

int debug  = 0;
int compatmode = 0;
extern char twiddle_toggle;

#if 0
static void
prom2boot(char *dev)
{
        char *cp, *lp = 0;
        int handle;
        char devtype[16];
        
        for (cp = dev; *cp; cp++)
                if (*cp == ':')
                        lp = cp;
        if (!lp)
                lp = cp;
        *lp = 0;
}
#endif

static int
bootoptions(const char *ap, char *loaddev, char *kernel, char *options)
{
        int v = 0;
        const char *start1 = NULL, *end1 = NULL, *start2 = NULL, *end2 = NULL;
        const char *path;
        char partition, *pp;

        *kernel  = '\0';
        *options = '\0';

        if (ap == NULL) {
                return (0);
        }

        while (*ap == ' ') {
                ap++;
        }

        if (*ap != '-') {
                start1 = ap;
                while (*ap != '\0' && *ap != ' ') {
                        ap++;
                }
                end1 = ap;

                while (*ap == ' ') {
                        ap++;
                }

                if (*ap != '-') {
                        start2 = ap;
                        while (*ap != '\0' && *ap != ' ') {
                                ap++;
                        }
                        end2 = ap;
                        while (*ap != '\0' && *ap == ' ') {
                                ap++;
                        }
                }
        }
        if (end2 == start2) {
                start2 = end2 = NULL;
        }
        if (end1 == start1) {
                start1 = end1 = NULL;
        }

        if (start1 == NULL) {
                /* only options */
        } else if (start2 == NULL) {
                memcpy(kernel, start1, (end1 - start1));
                kernel[end1 - start1] = '\0';
                path = filename(kernel, &partition);
                if (path == NULL) {
                        strcpy(loaddev, kernel);
                        kernel[0] = '\0';
                } else if (path != kernel) {
                        /* copy device part */
                        memcpy(loaddev, kernel, path-kernel);
                        loaddev[path-kernel] = '\0';
                        if (partition) {
                                pp = loaddev + strlen(loaddev);
                                pp[0] = ':';
                                pp[1] = partition;
                                pp[2] = '\0';
                        }
                        /* and kernel path */
                        strcpy(kernel, path);
                }
        } else {
                memcpy(loaddev, start1, (end1-start1));
                loaddev[end1-start1] = '\0';
                memcpy(kernel, start2, (end2 - start2));
                kernel[end2 - start2] = '\0';
        }

        twiddle_toggle = 1;
        strcpy(options, ap);
        while (*ap != '\0' && *ap != ' ' && *ap != '\t' && *ap != '\n') {
                BOOT_FLAG(*ap, v);
                switch(*ap++) {
                case 'D':
                        debug = 2;
                        break;
                case 'C':
                        compatmode = 1;
                        break;
                case 'T':
                        twiddle_toggle = 1 - twiddle_toggle;
                        break;
                default:
                        break;
                }
        }

        if (((v & RB_KDB) != 0) && (debug == 0)) {
                debug = 1;
        }

        DPRINTF(("bootoptions: device='%s', kernel='%s', options='%s'\n",
            loaddev, kernel, options));
        return (v);
}

/*
 * The older (those relying on ofwboot v1.8 and earlier) kernels can't handle
 * ksyms information unless it resides in a dedicated memory allocated from
 * PROM and aligned on NBPG boundary. This is because the kernels calculate
 * their ends on their own, they use address of 'end[]' reference which follows
 * text segment. Ok, allocate some memory from PROM and copy symbol information
 * over there.
 */
static void
ksyms_copyout(void **ssym, void **esym)
{
        uint8_t *addr;
        int kssize = (int)(long)((char *)*esym - (char *)*ssym + 1);

        DPRINTF(("ksyms_copyout(): ssym = %p, esym = %p, kssize = %d\n",
                                *ssym, *esym, kssize));

        if ( (addr = OF_claim(0, kssize, NBPG)) == (void *)-1) {
                panic("ksyms_copyout(): no space for symbol table");
        }

        memcpy(addr, *ssym, kssize);
        *ssym = addr;
        *esym = addr + kssize - 1;

        DPRINTF(("ksyms_copyout(): ssym = %p, esym = %p\n", *ssym, *esym));
}

/*
 * Prepare boot information and jump directly to the kernel.
 */
static void
jump_to_kernel(u_long *marks, char *kernel, char *args, void *ofw,
        int boothowto)
{
        int l, machine_tag;
        long newargs[4];
        void *ssym, *esym;
        vaddr_t bootinfo;
        struct btinfo_symtab bi_sym;
        struct btinfo_kernend bi_kend;
        struct btinfo_boothowto bi_howto;
        char *cp;
        char bootline[PROM_MAX_PATH * 2];

        /* Compose kernel boot line. */
        strncpy(bootline, kernel, sizeof(bootline));
        cp = bootline + strlen(bootline);
        if (*args) {
                *cp++ = ' ';
                strncpy(bootline, args, sizeof(bootline) - (cp - bootline));
        }
        *cp = 0; args = bootline;

        /* Record symbol information in the bootinfo. */
        bootinfo = bi_init(marks[MARK_END]);
        bi_sym.nsym = marks[MARK_NSYM];
        bi_sym.ssym = marks[MARK_SYM];
        bi_sym.esym = marks[MARK_END];
        bi_add(&bi_sym, BTINFO_SYMTAB, sizeof(bi_sym));
        bi_kend.addr= bootinfo + BOOTINFO_SIZE;
        bi_add(&bi_kend, BTINFO_KERNEND, sizeof(bi_kend));
        bi_howto.boothowto = boothowto;
        bi_add(&bi_howto, BTINFO_BOOTHOWTO, sizeof(bi_howto));
        if (bootinfo_pass_bootunit)
                bi_add(&bi_unit, BTINFO_BOOTDEV_UNIT,
                    sizeof(bi_unit));
        if (bootinfo_pass_bootdev) {
                struct {
                        struct btinfo_common common;
                        char name[256];
                } info;
                
                strcpy(info.name, bootdev);
                bi_add(&info, BTINFO_BOOTDEV, strlen(bootdev)
                        +sizeof(struct btinfo_bootdev));
        }

        sparc64_finalize_tlb(marks[MARK_DATA]);
        sparc64_bi_add();

        ssym  = (void*)(long)marks[MARK_SYM];
        esym  = (void*)(long)marks[MARK_END];

        DPRINTF(("jump_to_kernel(): ssym = %p, esym = %p\n", ssym, esym));

        /* Adjust ksyms pointers, if needed. */
        if (COMPAT_BOOT(marks) || compatmode) {
                ksyms_copyout(&ssym, &esym);
        }

        freeall();
        /*
         * When we come in args consists of a pointer to the boot
         * string.  We need to fix it so it takes into account
         * other params such as romp.
         */

        /*
         * Stash pointer to end of symbol table after the argument
         * strings.
         */
        l = strlen(args) + 1;
        memcpy(args + l, &esym, sizeof(esym));
        l += sizeof(esym);

        /*
         * Tell the kernel we're an OpenFirmware system.
         */
        machine_tag = SPARC_MACHINE_OPENFIRMWARE;
        memcpy(args + l, &machine_tag, sizeof(machine_tag));
        l += sizeof(machine_tag);

        /* 
         * Since we don't need the boot string (we can get it from /chosen)
         * we won't pass it in.  Just pass in esym and magic #
         */
        newargs[0] = SPARC_MACHINE_OPENFIRMWARE;
        newargs[1] = (long)esym;
        newargs[2] = (long)ssym;
        newargs[3] = (long)(void*)bootinfo;
        args = (char *)newargs;
        l = sizeof(newargs);

        /* if -D is set then pause in the PROM. */
        if (debug > 1) callrom();

        /*
         * Jump directly to the kernel. Solaris kernel and Sun PROM
         * flash updates expect ROMP vector in %o0, so we do. Format
         * of other parameters and their order reflect OF_chain()
         * symantics since this is what older NetBSD kernels rely on.
         * (see sparc64/include/bootinfo.h for specification).
         */
        DPRINTF(("jump_to_kernel(%lx, %lx, %lx, %lx, %lx) @ %p\n", (long)ofw,
                                (long)args, (long)l, (long)ofw, (long)ofw,
                                (void*)marks[MARK_ENTRY]));
        (*(entry_t)marks[MARK_ENTRY])((long)ofw, (long)args, (long)l, (long)ofw,
                                      (long)ofw);
        printf("Returned from kernel entry point!\n");
}

static void
start_kernel(char *kernel, char *bootline, void *ofw, int isfloppy,
        int boothowto)
{
        int fd;
        u_long marks[MARK_MAX] = {0};
        int flags = LOAD_ALL;

        if (isfloppy)
                flags &= ~LOAD_BACKWARDS;

        /*
         * First, load headers using default allocator and check whether kernel
         * entry address matches kernel text load address. If yes, this is the
         * old kernel designed for ofwboot v1.8 and therefore it must be mapped
         * by PROM. Otherwise, map the kernel with 4MB permanent pages.
         */
        loadfile_set_allocator(LOADFILE_NOP_ALLOCATOR);
        if ( (fd = loadfile(kernel, marks, LOAD_HDR|COUNT_TEXT)) != -1) {
                if (COMPAT_BOOT(marks) || compatmode) {
                        (void)printf("[c] ");
                        loadfile_set_allocator(LOADFILE_OFW_ALLOCATOR);
                } else {
                        loadfile_set_allocator(LOADFILE_MMU_ALLOCATOR);
                }
                (void)printf("Loading %s: ", kernel);

                if (fdloadfile(fd, marks, flags) != -1) {
                        close(fd);
                        jump_to_kernel(marks, kernel, bootline, ofw, boothowto);
                }
        }
        (void)printf("Failed to load '%s'.\n", kernel);
}

static void
help(void)
{
        printf( "enter a special command\n"
                "  halt\n"
                "  exit\n"
                "    to return to OpenFirmware\n"
                "  ?\n"
                "  help\n"
                "    to display this message\n"
                "or a boot specification:\n"
                "  [device] [kernel] [options]\n"
                "\n"
                "for example:\n"
                "  disk:a netbsd -s\n");
}

static void
do_config_command(const char *cmd, char *arg)
{
        DPRINTF(("do_config_command: %s\n", cmd));
        if (strcmp(cmd, "bootpartition") == 0) {
                char *c;

                DPRINTF(("switching boot partition to %s from %s\n",
                    arg, bootdev));
                c = strrchr(bootdev, ':');
                if (!c) return;
                if (c[1] == 0) return;
                if (strlen(arg) > strlen(c)) return;
                strcpy(c, arg);
                DPRINTF(("new boot device: %s\n", bootdev));
                bootinfo_pass_bootdev = true;
        }
}

static void
check_boot_config(void)
{
        if (!root_fs_quickseekable)
                return;

        perform_bootcfg(BOOTCFG_FILENAME, &do_config_command, 32768);
}

void
main(void *ofw)
{
        int boothowto, i = 0, isfloppy, kboothowto;

        char kernel[PROM_MAX_PATH];
        char bootline[PROM_MAX_PATH];

        /* Initialize OpenFirmware */
        romp = ofw;
        prom_init();

        printf("\r>> %s, Revision %s\n", bootprog_name, bootprog_rev);

        /* Figure boot arguments */
        strncpy(bootdev, prom_getbootpath(), sizeof(bootdev) - 1);
        kboothowto = boothowto =
            bootoptions(prom_getbootargs(), bootdev, kernel, bootline);
        isfloppy = bootdev_isfloppy(bootdev);

        for (;; *kernel = '\0') {
                if (boothowto & RB_ASKNAME) {
                        char cmdline[PROM_MAX_PATH];

                        printf("Boot: ");
                        kgets(cmdline, sizeof(cmdline));

                        if (!strcmp(cmdline,"exit") ||
                            !strcmp(cmdline,"halt")) {
                                prom_halt();
                        } else if (!strcmp(cmdline, "?") ||
                                   !strcmp(cmdline, "help")) {
                                help();
                                continue;
                        }

                        boothowto  = bootoptions(cmdline, bootdev, kernel,
                            bootline);
                        boothowto |= RB_ASKNAME;
                        i = 0;
                }

                if (*kernel == '\0') {
                        if (kernelnames[i] == NULL) {
                                boothowto |= RB_ASKNAME;
                                continue;
                        }
                        strncpy(kernel, kernelnames[i++], PROM_MAX_PATH);
                } else if (i == 0) {
                        /*
                         * Kernel name was passed via command line -- ask user
                         * again if requested image fails to boot.
                         */
                        boothowto |= RB_ASKNAME;
                }

                check_boot_config();
                start_kernel(kernel, bootline, ofw, isfloppy, kboothowto);

                /*
                 * Try next name from kernel name list if not in askname mode,
                 * enter askname on reaching list's end.
                 */
                if ((boothowto & RB_ASKNAME) == 0 && (kernelnames[i] != NULL)) {
                        printf(": trying %s...\n", kernelnames[i]);
                } else {
                        printf("\n");
                        boothowto |= RB_ASKNAME;
                }
        }

        (void)printf("Boot failed! Exiting to the Firmware.\n");
        prom_halt();
}