Subversion Repositories freemyipod

//

//

//    Copyright 2010 TheSeven

//

//

//    This file is part of emBIOS.

//

//    emBIOS is free software: you can redistribute it and/or

//    modify it under the terms of the GNU General Public License as

//    published by the Free Software Foundation, either version 2 of the

//    License, or (at your option) any later version.

//

//    emBIOS is distributed in the hope that it will be useful,

//    but WITHOUT ANY WARRANTY; without even the implied warranty of

//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

//    See the GNU General Public License for more details.

//

//    You should have received a copy of the GNU General Public License along

//    with emBIOS.  If not, see <http://www.gnu.org/licenses/>.

//

//

#include "global.h"

#include "thread.h"

#include "console.h"

#include "power.h"

#include "interrupt.h"

#include "ucl.h"

#include "util.h"

#include "execimage.h"

#ifdef HAVE_LCD

#include "lcd.h"

#include "lcdconsole.h"

#endif

#ifdef HAVE_I2C

#include "i2c.h"

#endif

#ifdef HAVE_USB

#include "usb/usb.h"

#endif

#ifdef HAVE_STORAGE

#include "storage.h"

#include "disk.h"

#include "file.h"

#endif

#ifdef HAVE_BOOTFLASH

#include "bootflash.h"

#endif

struct bootinfo_t

{

    char signature[8];

    int version;

    bool trydataflash;

    char dataflashpath[256];

    bool dataflashflags;

    bool trybootflash;

    char bootimagename[8];

    bool bootflashflags;

    bool trymemmapped;

    void* memmappedaddr;

    int memmappedsize;

    bool memmappedflags;

};

static const char welcomestring[] INITCONST_ATTR = "emBIOS v" VERSION " r" VERSION_SVN "\n\n";

static const char initthreadname[] INITCONST_ATTR = "Initialization thread";

static uint32_t initstack[0x400] INITSTACK_ATTR;

extern int _loadspaceend;

extern int _initstart;

struct bootinfo_t bootinfo_src INITHEAD_ATTR =

{

    .signature = "emBIboot",

    .version = 0,

    .trydataflash = false,

    .trybootflash = false,

    .trymemmapped = false

};

void boot()

{

    struct bootinfo_t bootinfo = bootinfo_src;

#ifdef HAVE_STORAGE

    if (bootinfo.trydataflash)

    {

        int fd = file_open(bootinfo.dataflashpath, O_RDONLY);

        if (fd < 0) goto dataflashfailed;

        int size = filesize(fd);

        if (size < 0) goto dataflashfailed;

        if (bootinfo.dataflashflags & 1)

        {

            void* addr = (void*)((((uint32_t)&_loadspaceend) - size) & ~(CACHEALIGN_SIZE - 1));

            if (read(fd, addr, size) != size) goto dataflashfailed;

            if (ucl_decompress(addr, size, &_initstart, (uint32_t*)&size)) goto dataflashfailed;

        }

        else if (read(fd, &_initstart, size) != size) goto dataflashfailed;

        if (execimage(&_initstart) < 0) return;

    }

dataflashfailed:

#endif

#ifdef HAVE_BOOTFLASH

    if (bootinfo.trybootflash)

    {

        int size = bootflash_filesize(bootinfo.bootimagename);

        if (size < 0) goto bootflashfailed;

#ifdef BOOTFLASH_IS_MEMMAPPED

        void* addr = bootflash_getaddr(bootinfo.bootimagename);

        if (!addr) goto bootflashfailed;

        if (bootinfo.bootflashflags & 1)

        {

            if (ucl_decompress(addr, size, &_initstart, (uint32_t*)&size)) goto bootflashfailed;

            if (execimage(&_initstart) < 0) return;

        }

        else if (bootinfo.bootflashflags & 2)

        {

            memcpy(&_initstart, addr, size);

            if (execimage(&_initstart) < 0) return;

        }

        else execimage(addr);

#else

        if (bootinfo.bootflashflags & 1)

        {

            void* addr = (void*)((((uint32_t)&_loadspaceend) - size) & ~(CACHEALIGN_SIZE - 1));

            if (bootflash_read(bootinfo.bootimagename, addr, 0, size) != size)

                goto bootflashfailed;

            if (ucl_decompress(addr, size, &_initstart, (uint32_t*)&size)) goto bootflashfailed;

        }

        else if (bootflash_read(bootinfo.bootimagename, &_initstart, 0, size) != size)

            goto bootflashfailed;

        if (execimage(&_initstart) < 0) return;

#endif

    }

bootflashfailed:

#endif

    if (bootinfo.trymemmapped)

    {

        int size = bootinfo.memmappedsize;

        if (bootinfo.bootflashflags & 1)

        {

            if (ucl_decompress(bootinfo.memmappedaddr, size, &_initstart, (uint32_t*)&size))

                goto memmappedfailed;

            if (execimage(&_initstart) < 0) return;

        }

        else if (bootinfo.bootflashflags & 2)

        {

            memcpy(&_initstart, bootinfo.memmappedaddr, size);

            if (execimage(&_initstart) < 0) return;

        }

        else if (execimage(bootinfo.memmappedaddr) < 0) return;

    }

memmappedfailed:

    if (bootinfo.trydataflash || bootinfo.trybootflash || bootinfo.trymemmapped)

        cputs(CONSOLE_BOOT, "Could not find a usable boot image!\n");

    cputs(CONSOLE_BOOT, "Waiting for USB commands\n\n");

}

void initthread() INITCODE_ATTR;

void initthread()

{

    cputs(CONSOLE_BOOT, welcomestring);

	#ifdef HAVE_I2C

    i2c_init();

	#endif

    power_init();

	#ifdef HAVE_USB

    usb_init();

	#endif

	#ifdef HAVE_STORAGE

    DEBUGF("Initializing storage drivers...");

    storage_init();

    DEBUGF("Initializing storage subsystem...");

    disk_init_subsystem();

    DEBUGF("Reading partition tables...");

    disk_init();

    DEBUGF("Mounting partitions...");

    disk_mount_all();

	#endif

    DEBUGF("Finished initialisation sequence");

    boot();

}

void init() INITCODE_ATTR;

void init()

{

    scheduler_init();

    console_init();

	#ifdef HAVE_LCD

    lcd_init();

    lcdconsole_init();

	#endif

    interrupt_init();

    thread_create(initthreadname, initthread, initstack,

                  sizeof(initstack), USER_THREAD, 127, true);

}