Subversion Repositories freemyipod

//

//

//    Copyright 2010 TheSeven

//

//

//    This file is part of emCORE.

//

//    emCORE 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.

//

//    emCORE 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 emCORE.  If not, see <http://www.gnu.org/licenses/>.

//

//

#include "global.h"

#include "bootflash.h"

#include "contextswitch.h"

#include "util.h"

#include "spi.h"

#include "s5l8702.h"

void bootflash_ce(int port, bool state)

{

    if (state)

    {

        if (port == 2) PDAT(0xe) &= ~0x40;

        else if (port == 1) PDAT(6) &= ~0x10;

        else PDAT(0) &= ~1;

    }

    else

    {

        if (port == 2) PDAT(0xe) |= 0x40;

        else if (port == 1) PDAT(6) |= 0x10;

        else PDAT(0) |= 1;

    }

}

void bootflash_wait_ready(int port)

{

    while (true)

    {

        bootflash_ce(port, true);

        spi_write(port, 5);

        if (!(spi_write(port, 0xff) & 1)) break;

        bootflash_ce(port, false);

    }

    bootflash_ce(port, false);

}

void bootflash_enable_writing(int port, bool state)

{

    if (!state)

    {

        bootflash_ce(port, true);

        spi_write(port, 4);

        bootflash_ce(port, false);

    }

    bootflash_ce(port, true);

    spi_write(port, 0x50);

    bootflash_ce(port, false);

    bootflash_ce(port, true);

    spi_write(port, 1);

    spi_write(port, state ? 0 : 0x1c);

    bootflash_ce(port, false);

    if (state)

    {

        bootflash_ce(port, true);

        spi_write(port, 6);

        bootflash_ce(port, false);

    }

}

void bootflash_readraw(void* addr, int offset, int size)

{

    spi_prepare(0);

    bootflash_wait_ready(0);

    bootflash_ce(0, true);

    spi_write(0, 3);

    spi_write(0, (offset >> 16) & 0xff);

    spi_write(0, (offset >> 8) & 0xff);

    spi_write(0, offset & 0xff);

    spi_read(0, size, addr);

    bootflash_ce(0, false);

    spi_release(0);

}

void bootflash_write_internal(int port, uint32_t addr, uint32_t size, void* buf)

{

    uint8_t* buffer = (uint8_t*)buf;

    bool first = true;

    spi_prepare(port);

    bootflash_wait_ready(port);

    bootflash_enable_writing(port, true);

    while (size)

    {

        bootflash_ce(port, true);

        spi_write(port, 0xad);

        if (first)

        {

            spi_write(port, (addr >> 16) & 0xff);

            spi_write(port, (addr >> 8) & 0xff);

            spi_write(port, addr & 0xff);

            first = false;

        }

        spi_write(port, *buffer++);

        spi_write(port, *buffer++);

        bootflash_ce(port, false);

        bootflash_wait_ready(port);

        size -= 2;

    }

    bootflash_enable_writing(port, false);

    spi_release(port);

}

void bootflash_erase_internal(int port, uint32_t addr)

{

    spi_prepare(port);

    bootflash_wait_ready(port);

    bootflash_enable_writing(port, true);

    bootflash_ce(port, true);

    spi_write(port, 0x20);

    spi_write(port, (addr >> 16) & 0xff);

    spi_write(port, (addr >> 8) & 0xff);

    spi_write(port, addr & 0xff);

    bootflash_ce(port, false);

    bootflash_enable_writing(port, false);

    spi_release(port);

}

int bootflash_compare(int offset, void* addr, int size)

{

    int i;

    int result = 0;

    uint8_t buf[32];

    spi_prepare(0);

    bootflash_wait_ready(0);

    bootflash_ce(0, true);

    spi_write(0, 3);

    spi_write(0, (offset >> 16) & 0xff);

    spi_write(0, (offset >> 8) & 0xff);

    spi_write(0, offset & 0xff);

    while (size > 0)

    {

        spi_read(0, MIN(sizeof(buf), size), buf);

        if (memcmp((uint8_t*)addr, buf, MIN(sizeof(buf), size))) result |= 1;

        for (i = 0; i < MIN(sizeof(buf), size); i += 2)

            if (buf[i] != 0xff) result |= 2;

        addr = (void*)(((uint32_t)addr) + sizeof(buf));

        size -= sizeof(buf);

    }

    bootflash_ce(0, false);

    spi_release(0);

    return result;

}

void bootflash_writeraw(void* addr, int offset, int size)

{

    int i;

    bool needswrite;

    while (size > 0)

    {

        int remainder = MIN(0x1000 - (offset & 0xfff), size);

        int contentinfo = bootflash_compare(offset, addr, remainder);

        if (contentinfo & 1)

        {

            if (contentinfo & 2) bootflash_erase_internal(0, offset & ~0xfff); 

            needswrite = false;

            for (i = 0; i < remainder; i += 1)

                if (((uint8_t*)addr)[i] != 0xff)

                {

                    needswrite = true;

                    break;

                }

            if (needswrite) bootflash_write_internal(0, offset, remainder, addr);

        }

        addr = (void*)(((uint32_t)addr) + remainder);

        offset += remainder;

        size -= remainder;

    }

}

static uint32_t findflashfile(const char* filename, uint32_t* size)

{

    uint32_t i;

    uint32_t buf[4];

    spi_prepare(0);

    bootflash_wait_ready(0);

    bootflash_ce(0, true);

    spi_write(0, 3);

    spi_write(0, 0);

    spi_write(0, 0);

    spi_write(0, 0);

    for (i = 0; i < 0x100; i++)

    {

        spi_read(0, 16, buf);

        if (!memcmp(buf, filename, 8))

        {

            *size = buf[3];

            bootflash_ce(0, false);

            spi_release(0);

            return buf[2];

        }

    }

    bootflash_ce(0, false);

    spi_release(0);

    return 0;

}

int bootflash_filesize(const char* filename)

{

    uint32_t size;

    if (findflashfile(filename, &size)) return size & 0xfffff;

    else return -1;

}

int bootflash_attributes(const char* filename)

{

    uint32_t size;

    if (findflashfile(filename, &size)) return size >> 20;

    else return -1;

}

void* bootflash_getaddr(const char* filename)

{

    return NULL;

}

int bootflash_read(const char* filename, void* addr, int offset, int size)

{

    uint32_t fsize;

    uint32_t file = findflashfile(filename, &fsize);

    if (!file) return -1;

    fsize &= 0xfffff;

    if (offset + size > fsize) size = fsize - offset;

    if (size > 0) bootflash_readraw(addr, file + offset, size);

    return size;

}

void* bootflash_getrawaddr(int offset)

{

    return NULL;

}

bool bootflash_is_memmapped()

{

    return false;

}