xref: /src/sys/arch/epoc32/stand/e32boot/exe/e32boot.cpp

/*	$NetBSD: e32boot.cpp,v 1.3 2013/06/20 15:30:00 kiyohara Exp $	*/
/*
 * Copyright (c) 2012, 2013 KIYOHARA Takashi
 * 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 <e32base.h>
#include <e32cons.h>
#include <e32def.h>
#include <e32hal.h>
#include <e32svr.h>	/* XXXXX */
#include <w32std.h>

#include "e32boot.h"
#include "netbsd.h"
#include "../../../include/bootinfo.h"

CConsoleBase *console;
LOCAL_C NetBSD *LoadNetBSDL(void);
LOCAL_C struct btinfo_common *CreateBootInfo(TAny *);
LOCAL_C struct btinfo_common *FindBootInfoL(struct btinfo_common *, int);
TUint SummaryBootInfoMemory(struct btinfo_common *);
LOCAL_C void E32BootL(void);

struct memmap {
	TUint address;
	TUint size;	/* KB */
};
struct memmap series5_4m[] = {{ 0xc0000000, 512 }, { 0xc0100000, 512 },
			      { 0xc0400000, 512 }, { 0xc0500000, 512 },
			      { 0xc1000000, 512 }, { 0xc1100000, 512 },
			      { 0xc1400000, 512 }, { 0xc1500000, 512 }};
struct memmap series5_8m[] = {{ 0xc0000000, 512 }, { 0xc0100000, 512 },
			      { 0xc0400000, 512 }, { 0xc0500000, 512 },
			      { 0xc1000000, 512 }, { 0xc1100000, 512 },
			      { 0xc1400000, 512 }, { 0xc1500000, 512 },
			      { 0xd0000000, 512 }, { 0xd0100000, 512 },
			      { 0xd0400000, 512 }, { 0xd0500000, 512 },
			      { 0xd1000000, 512 }, { 0xd1100000, 512 },
			      { 0xd1400000, 512 }, { 0xd1500000, 512 }};
struct memmap revo[] = {{ 0xc0000000, 4096 }, { 0xc0800000, 4096 }};
struct memmap revopuls[] = {{ 0xc0000000, 4096 }, { 0xc0800000, 4096 },
			    { 0xd0000000, 4096 }, { 0xd0800000, 4096 }};
struct memmap series5mx_16m[] = {{ 0xc0000000, 8192 }, { 0xc1000000, 8192 }};
struct memmap series5mxpro_24m[] = {{ 0xc0000000, 8192 }, { 0xc1000000, 8192 },
				    { 0xd0000000, 4096 }, { 0xd0800000, 4096 }};
struct memmap series5mxpro_32m[] = {{ 0xc0000000, 8192 }, { 0xc1000000, 8192 },
				    { 0xd0000000, 8192 }, { 0xd1000000, 8192 }};
struct memmap series7_16m[] = {{ 0xc0000000, 16384 }};
struct memmap series7_32m[] = {{ 0xc0000000, 16384 }, { 0xc8000000, 16384 }};

struct {
	char *model;
	TInt width;
	TInt height;
	TUint memsize;
	struct memmap *memmaps;
} memmaps[] = {
	{ "SERIES5 R1",	640, 240,  4096, series5_4m },
	{ "SERIES5 R1",	640, 240,  8192, series5_8m },
	{ "SERIES5 R1",	640, 320,  4096, series5_4m },	/* Geofox One */
	{ "SERIES5 R1",	640, 320,  8192, series5_8m },	/* Geofox One */
//	{ "SERIES5 R1",	640, 320, 16384, one_16m },
	{ "SERIES5 R1",	320, 200,  4096, series5_4m },	/* Osaris */
//	{ "SERIES5 R1",	320, 200, 16384, osaris_16m },
	{ "SERIES5mx",	480, 160,  8192, revo },
	{ "SERIES5mx",	480, 160, 16384, revopuls },
	{ "SERIES5mx",	640, 240, 16384, series5mx_16m },
	{ "SERIES5mx",	640, 240, 24576, series5mxpro_24m },
	{ "SERIES5mx",	640, 240, 32768, series5mxpro_32m },
	{ "SERIES7",	800, 600, 16384, series7_16m },
	{ "SERIES7",	800, 600, 32768, series7_32m },
};

class E32BootLogicalChannel : public RLogicalChannel {
public:
	TInt DoCreate(const TDesC *aChan, TInt aUnit, const TDesC *aDriver,
							const TDesC8 *anInfo)
	{

		return RLogicalChannel::DoCreate(E32BootName, TVersion(0, 0, 0),
						aChan, aUnit, aDriver, anInfo);
	}

	TInt DoControl(TInt aFunction, TAny *a1)
	{

		return RLogicalChannel::DoControl(aFunction, a1);
	}

	TInt DoControl(TInt aFunction, TAny *a1, TAny *a2)
	{

		return RLogicalChannel::DoControl(aFunction, a1, a2);
	}
};


LOCAL_C void
E32BootL(void)
{
	E32BootLogicalChannel *E32BootChannel = new E32BootLogicalChannel;
	NetBSD *netbsd = NULL;
	TScreenInfoV01 screenInfo;
	TPckg<TScreenInfoV01> sI(screenInfo);
	TBuf<32> ldd;
	TInt err;
	TUint membytes;
	TAny *buf, *safeAddress;
	struct btinfo_common *bootinfo;
	struct btinfo_model *model;
	struct btinfo_video *video;
	struct btinfo_bootargs *bootargs;

	console =
	    Console::NewL(E32BootName, TSize(KConsFullScreen, KConsFullScreen));

	buf = User::AllocL(ALIGN_SAFE_PAGE_SIZE);	/* bootinfo buffer */

	/* Put banner */
	console->Printf(_L("\n"));
	console->Printf(_L(">> %s, Revision %s\n"),
	    bootprog_name, bootprog_rev);

	UserSvr::ScreenInfo(sI);
	if (!screenInfo.iScreenAddressValid)
		User::Leave(KErrNotSupported);
	safeAddress = screenInfo.iScreenAddress;

	bootinfo = CreateBootInfo((TAny *)PAGE_ALIGN(buf));

	model = (struct btinfo_model *)FindBootInfoL(bootinfo, BTINFO_MODEL);
	console->Printf(_L(">> Model %s\n"), model->model);

	membytes = SummaryBootInfoMemory(bootinfo);
	console->Printf(_L(">> Memory %d k\n"), membytes / 1024);

	video = (struct btinfo_video *)FindBootInfoL(bootinfo, BTINFO_VIDEO);
	console->Printf(_L(">> Video %d x %d\n"), video->width, video->height);

	console->Printf(_L("\n"));

	bootargs =
	    (struct btinfo_bootargs *)FindBootInfoL(bootinfo, BTINFO_BOOTARGS);
	TRAP(err, netbsd = LoadNetBSDL());
	if (err != KErrNone)
		User::Leave(err);
	else if (netbsd == NULL)
		return;
	console->Printf(_L("\nLoaded\n"));

	int n, m;
	n = sizeof(bootargs->bootargs);
	m = (*netbsd->GetArgs()).Length();
	if (m > 0)
		Mem::Copy(bootargs->bootargs, &(*netbsd->GetArgs())[0],
		    n < m ? n : m);
	bootargs->bootargs[n < m ? n - 1 : m] = '\0';

	netbsd->ParseHeader();

	/* Load logical device(kernel part of e32boot). */
	if (_L(model->model).CompareF(_L("SERIES5 R1")) == 0)
		ldd = _L("e32boot-s5.ldd");
	else if (_L(model->model).CompareF(_L("SERIES5mx")) == 0)
		ldd = _L("e32boot-s5mx.ldd");
//	else if (_L(model->model).CompareF(_L("SERIES7")) == 0)
//		ldd = _L("e32boot-s7.ldd");	// not yet.
	else {
		console->Printf(_L("Not Supported machine\n"));
		console->Getch();
		User::Leave(KErrNotSupported);
	}
	err = User::LoadLogicalDevice(ldd);
	if (err != KErrNone && err != KErrAlreadyExists) {
		console->Printf(_L("LoadLogicalDevice failed: %d\n"), err);
		console->Getch();
		User::Leave(err);
	}
	/* Create channel to kernel part. */
	err = E32BootChannel->DoCreate(NULL, KNullUnit, NULL, NULL);
	if (err == KErrNone) {
		E32BootChannel->DoControl(KE32BootSetSafeAddress, safeAddress);
		E32BootChannel->DoControl(KE32BootBootNetBSD, netbsd, bootinfo);
	} else {
		console->Printf(_L("DoCreate failed: %d\n"), err);
		console->Getch();
	}

	User::FreeLogicalDevice(ldd);
	if (err != KErrNone)
		User::Leave(err);
}

GLDEF_C TInt E32Main(void)	/* main function called by E32 */
{

	__UHEAP_MARK;
	CTrapCleanup *cleanup = CTrapCleanup::New();

	TRAPD(error, E32BootL());
	__ASSERT_ALWAYS(!error, User::Panic(E32BootName, error));

	delete cleanup;
	__UHEAP_MARKEND;
	return 0;
}

LOCAL_C NetBSD *
LoadNetBSDL(void)
{
	NetBSD *netbsd = NULL;
	TBuf<KMaxCommandLine> input, *args;
	TPtrC Default = _L("C:\\netbsd");
	TPtrC Prompt = _L("Boot: ");
	TInt pos, err;
	TBool retry;

	input.Zero();
	args = new TBuf<KMaxCommandLine>;
	args->Zero();
	retry = false;
	console->Printf(Prompt);
	console->Printf(_L("["));
	console->Printf(Default);
	console->Printf(_L("]: "));
	console->SetPos(Prompt.Length() +
			_L("[").Length() +
			Default.Length() +
			_L("]: ").Length());
	pos = 0;
	while (1) {
		TChar gChar = console->Getch();
		switch (gChar) {
		case EKeyEscape:
			return NULL;

		case EKeyEnter:
			break;

		case EKeyBackspace:
			if (pos > 0) {
				pos--;
				input.Delete(pos, 1);
			}
			break;

		default:
			if (gChar.IsPrint()) {
				if (input.Length() < KMaxCommandLine) {
					TBuf<0x02> b;
					b.Append(gChar);
					input.Insert(pos++, b);
				}
			}
			break;
		}
		if (gChar == EKeyEnter) {
			input.TrimAll();
			if (input[0] == '-')
				input.Swap(*args);
			for (int i = 0; i < input.Length(); i++)
				if (input[i] == ' ') {
					args->Copy(input);
					input.SetLength(i);
					args->Delete(0, i + 1);
					break;
				}
			args->ZeroTerminate();

			if (input.Length() > 0) {
				TRAP(err, netbsd = NetBSD::New(input, *args));
			} else {
				TRAP(err, netbsd = NetBSD::New(Default, *args));
			}
			if (err == 0 && netbsd != NULL)
				break;
			console->Printf(_L("\nLoad failed: %d\n"), err);

			input.Zero();
			args->Zero();
			console->Printf(Prompt);
			pos = 0;
			retry = true;
		}
		TInt base = Prompt.Length();
		if (!retry)
			base += (_L("[").Length() + Default.Length() +
							_L("]: ").Length());
		console->SetPos(base + pos);
		console->ClearToEndOfLine();
		console->SetPos(base);
		console->Write(input);
		console->SetPos(base + pos);
	}

	return netbsd;
}

#define KB	* 1024

LOCAL_C struct btinfo_common *
CreateBootInfo(TAny *buf)
{
	TMachineInfoV1Buf MachInfo;
	TMemoryInfoV1Buf MemInfo;
	struct btinfo_common *bootinfo, *common;
	struct btinfo_model *model;
	struct btinfo_memory *memory;
	struct btinfo_video *video;
	struct btinfo_bootargs *bootargs;
	struct memmap *memmap;
	TUint memsize;
	TUint i;

	UserHal::MachineInfo(MachInfo);
	UserHal::MemoryInfo(MemInfo);

	common = bootinfo = (struct btinfo_common *)buf;

	/* Set machine name to bootinfo. */
	common->len = sizeof(struct btinfo_model);
	common->type = BTINFO_MODEL;
	model = (struct btinfo_model *)common;
	Mem::Copy(model->model, &MachInfo().iMachineName[0],
	    sizeof(model->model));
	common = &(model + 1)->common;

	/* Set video width/height to bootinfo. */
	common->len = sizeof(struct btinfo_video);
	common->type = BTINFO_VIDEO;
	video = (struct btinfo_video *)common;
	video->width = MachInfo().iDisplaySizeInPixels.iWidth;
	video->height = MachInfo().iDisplaySizeInPixels.iHeight;
	common = &(video + 1)->common;

	/* Set memory size to bootinfo. */
	memsize = MemInfo().iTotalRamInBytes / 1024;
	for (i = 0; i < sizeof(memmaps) / sizeof(memmaps[0]); i++) {
		if (_L(memmaps[i].model).CompareF(_L(model->model)) == 0 &&
		    memmaps[i].width == video->width &&
		    memmaps[i].height == video->height &&
		    memmaps[i].memsize == memsize) {
			memmap = memmaps[i].memmaps;
			while (memsize > 0) {
				common->len = sizeof(struct btinfo_memory);
				common->type = BTINFO_MEMORY;
				memory = (struct btinfo_memory *)common;
				memory->address = memmap->address;
				memory->size = memmap->size KB;
				common = &(memory + 1)->common;
				memsize -= memmap->size;
				memmap++;
			}
			break;
		}
	}
	if (i == sizeof(memmaps) / sizeof(memmaps[0])) {
		common->len = sizeof(struct btinfo_memory);
		common->type = BTINFO_MEMORY;
		memory = (struct btinfo_memory *)common;
		memory->address = 0xc0000000;		/* default is here */
		memory->size = 4096 KB;			/* XXXXX */
		common = &(memory + 1)->common;
	}

	common->len = sizeof(struct btinfo_bootargs);
	common->type = BTINFO_BOOTARGS;
	bootargs = (struct btinfo_bootargs *)common;
	bootargs->bootargs[0] = '\0';
	common = &(bootargs + 1)->common;

	common->len = 0;
	common->type = BTINFO_NONE;

	/* Terminate bootinfo. */
	return bootinfo;
}

#undef KB

LOCAL_C struct btinfo_common *
FindBootInfoL(struct btinfo_common *bootinfo, int type)
{
	struct btinfo_common *entry;

	entry = bootinfo;
	while (entry->type != BTINFO_NONE) {
		if (entry->type == type)
			return entry;
		entry = (struct btinfo_common *)((int)entry + entry->len);
	}
	User::Leave(KErrNotFound);

	/* NOTREACHED */

	return NULL;
}

TUint
SummaryBootInfoMemory(struct btinfo_common *bootinfo)
{
	struct btinfo_common *entry;
	struct btinfo_memory *memory;
	TUint memsize = 0;

	entry = bootinfo;
	while (entry->type != BTINFO_NONE) {
		if (entry->type == BTINFO_MEMORY) {
			memory = (struct btinfo_memory *)entry;
			memsize += memory->size;
		}
		entry = (struct btinfo_common *)((int)entry + entry->len);
	}
	return memsize;
}