/*	$NetBSD: boot.c,v 1.4 2015/12/13 18:24:50 christos Exp $	*/

/*-
 * Copyright (c) 2010 The NetBSD Foundation, Inc.
 * Copyright (c) 1999 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code was written by Alessandro Forin and Neil Pittman
 * at Microsoft Research and contributed to The NetBSD Foundation
 * by Microsoft Corporation.
 *
 * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 FOUNDATION OR CONTRIBUTORS
 * 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 <lib/libsa/stand.h>
#include <lib/libsa/loadfile.h>
#include <lib/libkern/libkern.h>

#include <sys/param.h>
#include <sys/exec.h>
#include <sys/exec_elf.h>

#include "common.h"
#include "bootinfo.h"
#include "start.h"

/*
 * We won't go overboard with gzip'd kernel names.  After all we can
 * still boot a gzip'd kernel called "netbsd.emips" - it doesn't need
 * the .gz suffix.
 */
char *kernelnames[] = {
	"netbsd",	"netbsd.gz",
	"netbsd.old",
	"onetbsd",
	"gennetbsd",
	"nfsnetbsd",
	NULL
};


void main (char *);
char *getboot(char *, char*);
static int devcanon(char *);

#define OPT_MAX PATH_MAX /* way overkill */

static int loadit(char *name, u_long *marks)
{
	printf("Loading: %s\n", name);
	memset(marks, 0, sizeof(*marks) * MARK_MAX);
	return (loadfile(name, marks, LOAD_ALL));
}

/*
 * The locore in start.S calls us with an 8KB stack carved after _end.
 * 
 */
void
main(char *stack_top)
{
	int autoboot = 1, win;
	char *name, **namep, *dev, *kernel;
	char bootpath[PATH_MAX], options[OPT_MAX];
	uint32_t entry;
	u_long marks[MARK_MAX];
	struct btinfo_symtab bi_syms;
	struct btinfo_bootpath bi_bpath;

	/* Init all peripherals, esp USART for printf and memory */
	init_board();

	/* On account of compression, we need a fairly large heap.
	 * To keep things simple, take one meg just below the 16 meg mark.
	 * That allows for a large kernel, and a 16MB configuration still works.
	 */
	setheap((void *)(0x81000000-(1024*1024)), (void *)0x81000000);

	/* On the BEE3 and the Giano simulator, we need a sec between the serial-line download complete
	 * and switching the serial line to PuTTY as console. Get a char to pause.
	 * This delay is also the practice on PCs so.
	 */
	Delay(200000);
	printf("Hit any char to boot..");
	(void)GetChar();

	/* print a banner */
	printf("\n");
	printf("NetBSD/emips " NETBSD_VERS " " BOOT_TYPE_NAME " Bootstrap, Revision %s\n",
	    bootprog_rev);

	/* initialise bootinfo structure early */
	bi_init(BOOTINFO_ADDR);

	/* Default is to auto-boot from the first disk */
	dev = "0/ace(0,0)/";
	kernel = kernelnames[0];
	options[0] = 0;

	win = 0;
	for (;!win;) {
	    strcpy(bootpath, dev);
	    strcat(bootpath, kernel);
	    name = getboot(bootpath,options);

	    if (name != NULL) {
	        win = (loadit(name, marks) == 0);
	    } else if (autoboot)
	        break;
	    autoboot = 0;
	}

	if (!win) {
		for (namep = kernelnames, win = 0; *namep != NULL && !win;
		    namep++) {
			kernel = *namep;
			strcpy(bootpath, dev);
			strcat(bootpath, kernel);
			win = (loadit(bootpath, marks) == 0);
			if (win) {
				name = bootpath;
			}
		}
	}
	if (!win)
		goto fail;

	strncpy(bi_bpath.bootpath, name/*kernel?*/, BTINFO_BOOTPATH_LEN);
	bi_add(&bi_bpath, BTINFO_BOOTPATH, sizeof(bi_bpath));

	entry = marks[MARK_ENTRY];
	bi_syms.nsym = marks[MARK_NSYM];
	bi_syms.ssym = marks[MARK_SYM];
	bi_syms.esym = marks[MARK_END];
	bi_add(&bi_syms, BTINFO_SYMTAB, sizeof(bi_syms));

	printf("Starting at 0x%x\n\n", entry);
	call_kernel(entry, name, options, BOOTINFO_MAGIC, bootinfo);
	(void)printf("KERNEL RETURNED!\n");

fail:
	(void)printf("Boot failed!  Halting...\n");
}

static inline int
parse(char *cmd, char *kname, char *optarg)
{
	char *arg = cmd;
	char *ep, *p;
	int c, i;

	while ((c = *arg++)) {
	    /* skip leading blanks */
	    if (c == ' ' || c == '\t' || c == '\n')
	        continue;
	    /* find separator, or eol */
	    for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++);
	    ep = p;
	    /* trim if separator */
	    if (*p)
	        *p++ = 0;
	    /* token is either "-opts" or "kernelname" */
	    if (c == '-') {
	        /* no overflow because whole line same length as optarg anyways */
	        while ((c = *arg++)) {
	            *optarg++ = c;
	        }
	        *optarg = 0;
	    } else {
	        arg--;
	        if ((i = ep - arg)) {
	            if ((size_t)i >= PATH_MAX)
	                return -1;
	            memcpy(kname, arg, i + 1);
	        }
	    }
	    arg = p;
	}
	return 0;
}

/* String returned is zero-terminated and at most PATH_MAX chars */
static inline void
getstr(char *cmd, int c)
{
	char *s;

	s = cmd;
	if (c == 0)
	    c = GetChar();
	for (;;) {
	    switch (c) {
	    case 0:
	        break;
	    case '\177':
	    case '\b':
	        if (s > cmd) {
	            s--;
	            printf("\b \b");
	        }
	        break;
	    case '\n':
	    case '\r':
	        *s = 0;
	        return;
	    default:
	        if ((s - cmd) < (PATH_MAX - 1))
	            *s++ = c;
	        xputchar(c);
	    }
	    c = GetChar();
	}
}

char *getboot(char *kname, char* optarg)
{
	char c = 0;
	char cmd[PATH_MAX];

	printf("\nDefault: %s%s %s\nboot: ", (*optarg) ? "-" : "", optarg, kname);
	if ((c = GetChar()) == -1)
	    return NULL;

	cmd[0] = 0;
	getstr(cmd,c);
	xputchar('\n');
	if (parse(cmd,kname,optarg))
	    xputchar('\a');
	else if (devcanon(kname) == 0)
	    return kname;
	return NULL;
}

/*
 * Make bootpath canonical, provides defaults when missing
 */
static int
devcanon(char *fname)
{
	int ctlr = 0, unit = 0, part = 0;
	int c;
	char device_name[20];
	char file_name[PATH_MAX];
	const char *cp;
	char *ncp;

	//printf("devcanon(%s)\n",fname);

	cp = fname;
	ncp = device_name;

	/* expect a string like '0/ace(0,0)/netbsd' e.g. ctrl/name(unit,part)/file
	 * Defaults: ctrl=0, name='ace', unit=0, part=0, file=<none>
	 */

	/* get controller number */
	if ((c = *cp) >= '0' && c <= '9') {
	    ctlr = c - '0';
	    c = *++cp;
	    if (c != '/')
	        return (ENXIO);
	    c = *++cp;
	}

	/* get device name */
	while ((c = *cp) != '\0') {
	    if ((c == '(') || (c == '/')) {
	        cp++;
	        break;
	    }
	    if (ncp < device_name + sizeof(device_name) - 1)
	        *ncp++ = c;
	    cp++;
	}
	/* set default if missing */
	if (ncp == device_name) {
	    strcpy(device_name,"ace");
	    ncp += 3;
	}

	/* get device number */
	if ((c = *cp) >= '0' && c <= '9') {
	    unit = c - '0';
	    c = *++cp;
	}

	if (c == ',') {
	    /* get partition number */
	    if ((c = *++cp) >= '0' && c <= '9') {
	        part = c - '0';
	        c = *++cp;
	    }
	}

	if (c == ')')
	    c = *++cp;
	if (c == '/')
	    cp++;

	*ncp = '\0';

	/* Copy kernel name before we overwrite, then do it */
	strcpy(file_name, (*cp) ? cp : kernelnames[0]);
	snprintf(fname, PATH_MAX, "%c/%s(%c,%c)/%s",
	        ctlr + '0', device_name, unit + '0', part + '0', file_name);

	//printf("devcanon -> %s\n",fname);

	return (0);
}
