* Copyright (c) 2007 The NetBSD Foundation, Inc.

/* $NetBSD: main.c,v 1.34 2022/09/22 14:27:02 riastradh Exp $ */

/*-
* Copyright (c) 2007 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Tohru Nishimura.
*
* 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 <sys/param.h>
#include <sys/reboot.h>

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

#include <machine/bootinfo.h>

#include "globals.h"

#ifdef DEBUG
int debug = 1;
#endif

static const struct bootarg {
const char *name;
int value;
} bootargs[] = {
{ "multi", RB_AUTOBOOT },
{ "auto", RB_AUTOBOOT },
{ "ask", RB_ASKNAME },
{ "single", RB_SINGLE },
{ "ddb", RB_KDB },
{ "userconf", RB_USERCONF },
{ "norm", AB_NORMAL },
{ "quiet", AB_QUIET },
{ "verb", AB_VERBOSE },
{ "silent", AB_SILENT },
{ "debug", AB_DEBUG },
{ "altboot", -1 }
};

/* default PATA drive configuration is "10": single master on first channel */
static char *drive_config = "10";

void *bootinfo; /* low memory reserved to pass bootinfo structures */
int bi_size; /* BOOTINFO_MAXSIZE */
char *bi_next;

void bi_init(void *);
void bi_add(void *, int, int);

struct btinfo_memory bi_mem;
struct btinfo_console bi_cons;
struct btinfo_clock bi_clk;
struct btinfo_prodfamily bi_fam;
struct btinfo_model bi_model;
struct btinfo_bootpath bi_path;
struct btinfo_rootdevice bi_rdev;
struct btinfo_net bi_net;
struct btinfo_modulelist *btinfo_modulelist;
size_t btinfo_modulelist_size;

struct boot_module {
char *bm_kmod;
ssize_t bm_len;
struct boot_module *bm_next;
};
struct boot_module *boot_modules;
char module_base[80];
uint32_t kmodloadp;
int modules_enabled = 0;

#define MAXMODNAME 32
void module_add(const char *);
void module_add_split(const char *);
void module_load(const char *);
int module_open(struct boot_module *);

void main(int, char **, char *, char *);

extern char bootprog_name[], bootprog_rev[];
extern char newaltboot[], newaltboot_end[];

struct pcidev lata[2];
struct pcidev lnif[2];
struct pcidev lusb[3];
int nata, nnif, nusb;

int brdtype;
uint32_t busclock, cpuclock;

static int check_bootname(char *);
static int input_cmdline(char **, int);
static int parse_cmdline(char **, int, char *, char *);
static int is_space(char);
#ifdef DEBUG
static void sat_test(void);
static void findflash(void);
#endif

#define BNAME_DEFAULT "wd0:"
#define MAX_ARGS 10

void
main(int argc, char *argv[], char *bootargs_start, char *bootargs_end)
{
unsigned long marks[MARK_MAX];
struct brdprop *brdprop;
char *new_argv[MAX_ARGS];
char *bname;
ssize_t len;
int err, fd, howto, i, n;

printf("\n>> %s altboot, revision %s\n", bootprog_name, bootprog_rev);

brdprop = brd_lookup(brdtype);
printf(">> %s, cpu %u MHz, bus %u MHz, %dMB SDRAM\n", brdprop->verbose,
cpuclock / 1000000, busclock / 1000000, bi_mem.memsize >> 20);

nata = pcilookup(PCI_CLASS_IDE, lata, 2);
if (nata == 0)
nata = pcilookup(PCI_CLASS_RAID, lata, 2);
if (nata == 0)
nata = pcilookup(PCI_CLASS_MISCSTORAGE, lata, 2);
if (nata == 0)
nata = pcilookup(PCI_CLASS_SCSI, lata, 2);
nnif = pcilookup(PCI_CLASS_ETH, lnif, 2);
nusb = pcilookup(PCI_CLASS_USB, lusb, 3);

#ifdef DEBUG
if (nata == 0)
printf("No IDE/SATA found\n");
else for (n = 0; n < nata; n++) {
int b, d, f, bdf, pvd;
bdf = lata[n].bdf;
pvd = lata[n].pvd;
pcidecomposetag(bdf, &b, &d, &f);
printf("%04x.%04x DSK %02d:%02d:%02d\n",
PCI_VENDOR(pvd), PCI_PRODUCT(pvd), b, d, f);
}
if (nnif == 0)
printf("no NET found\n");
else for (n = 0; n < nnif; n++) {
int b, d, f, bdf, pvd;
bdf = lnif[n].bdf;
pvd = lnif[n].pvd;
pcidecomposetag(bdf, &b, &d, &f);
printf("%04x.%04x NET %02d:%02d:%02d\n",
PCI_VENDOR(pvd), PCI_PRODUCT(pvd), b, d, f);
}
if (nusb == 0)
printf("no USB found\n");
else for (n = 0; n < nusb; n++) {
int b, d, f, bdf, pvd;
bdf = lusb[0].bdf;
pvd = lusb[0].pvd;
pcidecomposetag(bdf, &b, &d, &f);
printf("%04x.%04x USB %02d:%02d:%02d\n",
PCI_VENDOR(pvd), PCI_PRODUCT(pvd), b, d, f);
}
#endif

pcisetup();
pcifixup();

/*
* When argc is too big then it is probably a pointer, which could
* indicate that we were launched as a Linux kernel module using
* "bootm".
*/
if (argc > MAX_ARGS) {
if (argv != NULL) {
/*
* initrd image was loaded:
* check if it contains a valid altboot command line
*/
char *p = (char *)argv;

if (strncmp(p, "altboot:", 8) == 0) {
*p = 0;
for (p = p + 8; *p >= ' '; p++);
argc = parse_cmdline(new_argv, MAX_ARGS,
((char *)argv) + 8, p);
argv = new_argv;
} else
argc = 0; /* boot default */
} else {
/* parse standard Linux bootargs */
argc = parse_cmdline(new_argv, MAX_ARGS,
bootargs_start, bootargs_end);
argv = new_argv;
}
}

/* look for a PATA drive configuration string under the arguments */
for (n = 1; n < argc; n++) {
if (strncmp(argv[n], "ide:", 4) == 0 &&
argv[n][4] >= '0' && argv[n][4] <= '2') {
drive_config = &argv[n][4];
break;
}
}

/* initialize a disk driver */
for (i = 0, n = 0; i < nata; i++)
n += dskdv_init(&lata[i]);
if (n == 0)
printf("IDE/SATA device driver was not found\n");

/* initialize a network interface */
for (n = 0; n < nnif; n++)
if (netif_init(&lnif[n]) != 0)
break;
if (n >= nnif)
printf("no NET device driver was found\n");

/* wait 2s for user to enter interactive mode */
for (n = 200; n >= 0; n--) {
if (n % 100 == 0)
printf("\rHit any key to enter interactive mode: %d",
n / 100);
if (tstchar()) {
#ifdef DEBUG
unsigned c;

c = toupper(getchar());
if (c == 'C') {
/* controller test terminal */
sat_test();
n = 200;
continue;
}
else if (c == 'F') {
/* find strings in Flash ROM */
findflash();
n = 200;
continue;
}
#else
(void)getchar();
#endif
/* enter command line */
argv = new_argv;
argc = input_cmdline(argv, MAX_ARGS);
break;
}
delay(10000);
}
putchar('\n');

howto = RB_AUTOBOOT; /* default is autoboot = 0 */

/* get boot options and determine bootname */
for (n = 1; n < argc; n++) {
if (strncmp(argv[n], "ide:", 4) == 0)
continue; /* ignore drive configuration argument */

for (i = 0; i < sizeof(bootargs) / sizeof(bootargs[0]); i++) {
if (strncasecmp(argv[n], bootargs[i].name,
strlen(bootargs[i].name)) == 0) {
howto |= bootargs[i].value;
break;
}
}
if (i >= sizeof(bootargs) / sizeof(bootargs[0]))
break; /* break on first unknown string */
}

/*
* If no device name is given, we construct a list of drives
* which have valid disklabels.
*/
if (n >= argc) {
static const size_t blen = sizeof("wdN:");
n = 0;
argc = 0;
argv = alloc(MAX_UNITS * (sizeof(char *) + blen));
bname = (char *)(argv + MAX_UNITS);
for (i = 0; i < MAX_UNITS; i++) {
if (!dlabel_valid(i))
continue;
snprintf(bname, blen, "wd%d:", i);
argv[argc++] = bname;
bname += blen;
}
/* use default drive if no valid disklabel is found */
if (argc == 0) {
argc = 1;
argv[0] = BNAME_DEFAULT;
}
}

/* try to boot off kernel from the drive list */
while (n < argc) {
bname = argv[n++];

if (check_bootname(bname) == 0) {
printf("%s not a valid bootname\n", bname);
continue;
}

if ((fd = open(bname, 0)) < 0) {
if (errno == ENOENT)
printf("\"%s\" not found\n", bi_path.bootpath);
continue;
}
printf("loading \"%s\" ", bi_path.bootpath);
marks[MARK_START] = 0;

if (howto == -1) {
/* load another altboot binary and replace ourselves */
len = read(fd, (void *)0x100000, 0x1000000 - 0x100000);
if (len == -1)
goto loadfail;
close(fd);
netif_shutdown_all();

memcpy((void *)0xf0000, newaltboot,
newaltboot_end - newaltboot);
__syncicache((void *)0xf0000,
newaltboot_end - newaltboot);
printf("Restarting...\n");
run((void *)1, argv, (void *)0x100000, (void *)len,
(void *)0xf0000);
}

err = fdloadfile(fd, marks, LOAD_KERNEL);
close(fd);
if (err != 0)
continue;

printf("entry=%p, ssym=%p, esym=%p\n",
(void *)marks[MARK_ENTRY],
(void *)marks[MARK_SYM],
(void *)marks[MARK_END]);

bootinfo = (void *)0x4000;
bi_init(bootinfo);
bi_add(&bi_cons, BTINFO_CONSOLE, sizeof(bi_cons));
bi_add(&bi_mem, BTINFO_MEMORY, sizeof(bi_mem));
bi_add(&bi_clk, BTINFO_CLOCK, sizeof(bi_clk));
bi_add(&bi_path, BTINFO_BOOTPATH, sizeof(bi_path));
bi_add(&bi_rdev, BTINFO_ROOTDEVICE, sizeof(bi_rdev));
bi_add(&bi_fam, BTINFO_PRODFAMILY, sizeof(bi_fam));
if (brdtype == BRD_SYNOLOGY || brdtype == BRD_DLINKDSM) {
/* need to pass this MAC address to kernel */
bi_add(&bi_net, BTINFO_NET, sizeof(bi_net));
}
bi_add(&bi_model, BTINFO_MODEL, sizeof(bi_model));

if (modules_enabled) {
if (fsmod != NULL)
module_add_split(fsmod);
kmodloadp = marks[MARK_END];
btinfo_modulelist = NULL;
module_load(bname);
if (btinfo_modulelist != NULL &&
btinfo_modulelist->num > 0)
bi_add(btinfo_modulelist, BTINFO_MODULELIST,
btinfo_modulelist_size);
}

launchfixup();
netif_shutdown_all();

__syncicache((void *)marks[MARK_ENTRY],
(u_int)marks[MARK_SYM] - (u_int)marks[MARK_ENTRY]);

run((void *)marks[MARK_SYM], (void *)marks[MARK_END],
(void *)howto, bootinfo, (void *)marks[MARK_ENTRY]);

/* should never come here */
printf("exec returned. Restarting...\n");
_rtt();
}
loadfail:
printf("load failed. Restarting...\n");
_rtt();
}

void
bi_init(void *addr)
{
struct btinfo_magic bi_magic;

memset(addr, 0, BOOTINFO_MAXSIZE);
bi_next = (char *)addr;
bi_size = 0;

bi_magic.magic = BOOTINFO_MAGIC;
bi_add(&bi_magic, BTINFO_MAGIC, sizeof(bi_magic));
}

void
bi_add(void *new, int type, int size)
{
struct btinfo_common *bi;

if (bi_size + size > BOOTINFO_MAXSIZE)
return; /* XXX error? */

bi = new;
bi->next = size;
bi->type = type;
memcpy(bi_next, new, size);
bi_next += size;
}

/*
* Add a /-separated list of module names to the boot list
*/
void
module_add_split(const char *name)
{
char mod_name[MAXMODNAME];
int i;
const char *mp = name;
char *ep;

while (*mp) { /* scan list of module names */
i = MAXMODNAME;
ep = mod_name;
while (--i) { /* scan for end of first name */
*ep = *mp;
if (*ep == '/') /* NUL-terminate the name */
*ep = '\0';

if (*ep == 0 ) { /* add non-empty name */
if (ep != mod_name)
module_add(mod_name);
break;
}
ep++; mp++;
}
if (*ep != 0) {
printf("module name too long\n");
return;
}
if (*mp == '/') { /* skip separator if more */
mp++;
}
}
}

void
module_add(const char *name)
{
struct boot_module *bm, *bmp;

while (*name == ' ' || *name == '\t')
++name;

bm = alloc(sizeof(struct boot_module) + strlen(name) + 1);
if (bm == NULL) {
printf("couldn't allocate module %s\n", name);
return;
}

bm->bm_kmod = (char *)(bm + 1);
bm->bm_len = -1;
bm->bm_next = NULL;
strcpy(bm->bm_kmod, name);
if ((bmp = boot_modules) == NULL)
boot_modules = bm;
else {
while (bmp->bm_next != NULL)
bmp = bmp->bm_next;
bmp->bm_next = bm;
}
}

#define PAGE_SIZE 4096
#define alignpg(x) (((x)+PAGE_SIZE-1) & ~(PAGE_SIZE-1))

void
module_load(const char *kernel_path)
{
struct boot_module *bm;
struct bi_modulelist_entry *bi;
struct stat st;
char *p;
int size, fd;

strcpy(module_base, kernel_path);
if ((p = strchr(module_base, ':')) == NULL)
return; /* eeh?! */
p += 1;
size = sizeof(module_base) - (p - module_base);

if (netbsd_version / 1000000 % 100 == 99) {
/* -current */
snprintf(p, size,
"/stand/sandpoint/%d.%d.%d/modules",
netbsd_version / 100000000,
netbsd_version / 1000000 % 100,
netbsd_version / 100 % 10000);
}
else if (netbsd_version != 0) {
/* release */
snprintf(p, size,
"/stand/sandpoint/%d.%d/modules",
netbsd_version / 100000000,
netbsd_version / 1000000 % 100);
}

/*
* 1st pass; determine module existence
*/
size = 0;
for (bm = boot_modules; bm != NULL; bm = bm->bm_next) {
fd = module_open(bm);
if (fd == -1)
continue;
if (fstat(fd, &st) == -1 || st.st_size == -1) {
printf("WARNING: couldn't stat %s\n", bm->bm_kmod);
close(fd);
continue;
}
bm->bm_len = (int)st.st_size;
close(fd);
size += sizeof(struct bi_modulelist_entry);
}
if (size == 0)
return;

size += sizeof(struct btinfo_modulelist);
btinfo_modulelist = alloc(size);
if (btinfo_modulelist == NULL) {
printf("WARNING: couldn't allocate module list\n");
return;
}
btinfo_modulelist_size = size;
btinfo_modulelist->num = 0;

/*
* 2nd pass; load modules into memory
*/
kmodloadp = alignpg(kmodloadp);
bi = (struct bi_modulelist_entry *)(btinfo_modulelist + 1);
for (bm = boot_modules; bm != NULL; bm = bm->bm_next) {
if (bm->bm_len == -1)
continue; /* already found unavailable */
fd = module_open(bm);
printf("module \"%s\" ", bm->bm_kmod);
size = read(fd, (char *)kmodloadp, SSIZE_MAX);
if (size < bm->bm_len)
printf("WARNING: couldn't load");
else {
snprintf(bi->kmod, sizeof(bi->kmod), "%s", bm->bm_kmod);
bi->type = BI_MODULE_ELF;
bi->len = size;
bi->base = kmodloadp;
btinfo_modulelist->num += 1;
printf("loaded at 0x%08x size 0x%x", kmodloadp, size);
kmodloadp += alignpg(size);
bi += 1;
}
printf("\n");
close(fd);
}
btinfo_modulelist->endpa = kmodloadp;
}

int
module_open(struct boot_module *bm)
{
char path[80];
int fd;

snprintf(path, sizeof(path),
"%s/%s/%s.kmod", module_base, bm->bm_kmod, bm->bm_kmod);
fd = open(path, 0);
return fd;
}

/*
* Return the drive configuration for the requested channel 'ch'.
* Channel 2 is the first channel of the next IDE controller.
* 0: for no drive present on channel
* 1: for master drive present on channel, no slave
* 2: for master and slave drive present
*/
int
get_drive_config(int ch)
{
if (drive_config != NULL) {
if (strlen(drive_config) <= ch)
return 0; /* an unspecified channel is unused */
if (drive_config[ch] >= '0' && drive_config[ch] <= '2')
return drive_config[ch] - '0';
}
return -1;
}

void *
allocaligned(size_t size, size_t align)
{
uint32_t p;

if (align-- < 2)
return alloc(size);
p = (uint32_t)alloc(size + align);
return (void *)((p + align) & ~align);
}

static int hex2nibble(char c)
{

if (c >= 'a')
c &= ~0x20;
if (c >= 'A' && c <= 'F')
c -= 'A' - ('9' + 1);
else if (c < '0' || c > '9')
return -1;

return c - '0';
}

uint32_t
read_hex(const char *s)
{
int n;
uint32_t val;

val = 0;
while ((n = hex2nibble(*s++)) >= 0)
val = (val << 4) | n;
return val;
}

static int
check_bootname(char *s)
{
/*
* nfs:
* nfs:<bootfile>
* tftp:
* tftp:<bootfile>
* wd[N[P]]:<bootfile>
* mem:<address>
*
* net is a synonym of nfs.
*/
if (strncmp(s, "nfs:", 4) == 0 || strncmp(s, "net:", 4) == 0 ||
strncmp(s, "tftp:", 5) == 0 || strncmp(s, "mem:", 4) == 0)
return 1;
if (s[0] == 'w' && s[1] == 'd') {
s += 2;
if (*s != ':' && *s >= '0' && *s <= '3') {
++s;
if (*s != ':' && *s >= 'a' && *s <= 'p')
++s;
}
return *s == ':';
}
return 0;
}

static int input_cmdline(char **argv, int maxargc)
{
char *cmdline;

printf("\nbootargs> ");
cmdline = alloc(256);
kgets(cmdline, 256);

return parse_cmdline(argv, maxargc, cmdline,
cmdline + strlen(cmdline));
}

static int
parse_cmdline(char **argv, int maxargc, char *p, char *end)
{
int argc;

argv[0] = "";
for (argc = 1; argc < maxargc && p < end; argc++) {
while (is_space(*p))
p++;
if (p >= end)
break;
argv[argc] = p;
while (!is_space(*p) && p < end)
p++;
*p++ = '\0';
}

return argc;
}

static int
is_space(char c)
{

return c > '\0' && c <= ' ';
}

#ifdef DEBUG
static void
findflash(void)
{
char buf[256];
int i, n;
unsigned char c, *p;

for (;;) {
printf("\nfind> ");
kgets(buf, sizeof(buf));
if (tolower((unsigned)buf[0]) == 'x')
break;
for (i = 0, n = 0, c = 0; buf[i]; i++) {
c <<= 4;
c |= hex2nibble(buf[i]);
if (i & 1)
buf[n++] = c;
}
printf("Searching for:");
for (i = 0; i < n; i++)
printf(" %02x", buf[i]);
printf("\n");
for (p = (unsigned char *)0xff000000;
p <= (unsigned char *)(0xffffffff-n); p++) {
for (i = 0; i < n; i++) {
if (p[i] != buf[i])
break;
}
if (i >= n)
printf("Found at %08x\n", (unsigned)p);
}
}
}

static void
sat_test(void)
{
char buf[1024];
int i, j, n, pos;
unsigned char c;

putchar('\n');
for (;;) {
do {
for (pos = 0; pos < 1024 && sat_tstch() != 0; pos++)
buf[pos] = sat_getch();
if (pos > 1023)
break;
delay(100000);
} while (sat_tstch());

for (i = 0; i < pos; i += 16) {
if ((n = i + 16) > pos)
n = pos;
for (j = 0; j < n; j++)
printf("%02x ", (unsigned)buf[i + j]);
for (; j < 16; j++)
printf(" ");
putchar('\"');
for (j = 0; j < n; j++) {
c = buf[i + j];
putchar((c >= 0x20 && c <= 0x7e) ? c : '.');
}
printf("\"\n");
}

printf("controller> ");
kgets(buf, sizeof(buf));
if (buf[0] == '*' && buf[1] == 'X')
break;

if (buf[0] == '0' && tolower((unsigned)buf[1]) == 'x') {
for (i = 2, n = 0, c = 0; buf[i]; i++) {
c <<= 4;
c |= hex2nibble(buf[i]);
if (i & 1)
buf[n++] = c;
}
} else
n = strlen(buf);

if (n > 0)
sat_write(buf, n);
}
}
#endif