/*      $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;
}