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 "storage.h"
#include "fat32.h"
#include "util.h"


uint32_t fat32_ok;
uint32_t fat32_startsector;
uint32_t fat32_secperclus;
uint32_t fat32_database;
uint32_t fat32_fatbase;
uint32_t fat32_fatsize;
uint32_t fat32_fatcount;
uint32_t fat32_sectorcount;
uint32_t fat32_clustercount;
uint32_t fat32_rootdirclus;
uint32_t fat32_buf1[0x200] __attribute__((aligned(16)));
uint32_t fat32_buf2[0x200] __attribute__((aligned(16)));


uint32_t fat32_get_root()
{
    return fat32_rootdirclus;
}

uint32_t fat32_get_clusterchain(uint32_t clusterchain, uint32_t maxsize, void* buffer)
{
    uint32_t i;
    for (i = 0; i < (maxsize >> 11); )
    {
        uint32_t sector = (clusterchain - 2) * fat32_secperclus + fat32_database;
        uint32_t count = fat32_secperclus;
        if (count + i > (maxsize >> 11)) count = (maxsize >> 11) - i;
        uint32_t fatsector = fat32_fatbase + (clusterchain >> 9);
        if (storage_read(fatsector, 1, &((uint32_t*)buffer)[i << 9])) return 1;
        clusterchain = ((uint32_t*)buffer)[(i << 9) + (clusterchain & 0x1FF)];
        if (storage_read(sector, count, &((uint32_t*)buffer)[i << 9])) return 1;
        i += count;
        if (clusterchain >= 0x0ffffff0) return 0;
    }
    return clusterchain;
}

uint32_t fat32_get_direntry(uint32_t clusterchain, const char* filename, uint32_t* filesize)
{
    uint32_t i, j;
    while (clusterchain > 1 && clusterchain < 0x0ffffff0)
    {
        uint32_t sector = (clusterchain - 2) * fat32_secperclus + fat32_database;
        for (j = 0; j < fat32_secperclus; j++)
        {
            if (storage_read(sector + j, 1, fat32_buf1)) return 1;
            for (i = 0; i < 0x200; i += 8)
                if (((uint8_t*)fat32_buf1)[i << 2] == 0) return 0;
                else if (((uint8_t*)fat32_buf1)[i << 2] == 0xe5) continue;
                else if (memcmp(&fat32_buf1[i], filename, 11) == 0)
                {
                    *filesize = fat32_buf1[i + 7];
                    return (((uint16_t*)fat32_buf1)[(i << 1) + 0xA] << 16)
                         | ((uint16_t*)fat32_buf1)[(i << 1) + 0xD];
                }
        }
        uint32_t fatsector = fat32_fatbase + (clusterchain >> 9);
        if (storage_read(fatsector, 1, fat32_buf1)) return 1;
        clusterchain = fat32_buf1[(i << 9) + (clusterchain & 0x1FF)];
    }
    return 0;
}

uint32_t fat32_delete_clusterchain(uint32_t clusterchain)
{
    while (1)
    {
        uint32_t fatsector = fat32_fatbase + (clusterchain >> 9);
        if (storage_read(fatsector, 1, fat32_buf1)) return 1;
        clusterchain = fat32_buf1[clusterchain & 0x1FF];
        fat32_buf1[(clusterchain & 0x1FF)] = 0;
        if (storage_write(fatsector, 1, fat32_buf1)) return 1;
        if (clusterchain >= 0x0ffffff0) return 0;
    }
}

uint32_t fat32_delete_direntry(uint32_t clusterchain, const char* filename)
{
    uint32_t i, j;
    while (clusterchain > 1 && clusterchain < 0x0ffffff0)
    {
        uint32_t sector = (clusterchain - 2) * fat32_secperclus + fat32_database;
        for (j = 0; j < fat32_secperclus; j++)
        {
            if (storage_read(sector + j, 1, fat32_buf1)) return 1;
            for (i = 0; i < 0x200; i += 8)
                if (((uint8_t*)fat32_buf1)[i << 2] == 0) return 0;
                else if (((uint8_t*)fat32_buf1)[i << 2] == 0xe5) continue;
                else if (memcmp(&fat32_buf1[i], filename, 11) == 0)
                {
                    ((uint8_t*)fat32_buf1)[i << 2] = 0xe5;
                    if (storage_write(sector + j, 1, fat32_buf1)) return 1;
                    return 0;
                }
        }
        uint32_t fatsector = fat32_fatbase + (clusterchain >> 9);
        if (storage_read(fatsector, 1, fat32_buf1)) return 1;
        clusterchain = fat32_buf1[(i << 9) + (clusterchain & 0x1FF)];
    }
    return 0;
}

uint32_t fat32_store_stream(void* buffer, uint32_t size)
{
    uint32_t i;
    uint32_t clusterchain = 0;
    uint32_t scanidx = 2;
    uint32_t scansect = 0xffffffff;
    uint32_t lastidx;
    uint32_t lastsect = 0xffffffff;
    uint32_t dirty = 0;
    while (size)
    {
        while (scanidx < fat32_clustercount + 2)
        {
            if ((scanidx >> 9) != scansect)
            {
                scansect = scanidx >> 9;
                if (storage_read(fat32_fatbase + scansect, 1, fat32_buf1)) return 0;
            }
            if (!fat32_buf1[scanidx & 0x1ff]) break;
            scanidx++;
        }
        if (scanidx >= fat32_clustercount + 2) return 0;
        if (!clusterchain) clusterchain = scanidx;
        else
        {
            fat32_buf2[lastidx & 0x1ff] = scanidx;
            dirty = 1;
        }
        lastidx = scanidx;
        if ((lastidx >> 9) != lastsect)
        {
            if (dirty)
                if (storage_write(fat32_fatbase + lastsect, 1, fat32_buf2)) return 0;
            dirty = 0;
            lastsect = lastidx >> 9;
            memcpy(fat32_buf2, fat32_buf1, 0x800);
        }
        uint32_t sector = (scanidx - 2) * fat32_secperclus + fat32_database;
        uint32_t count = (size + 0x7ff) >> 11;
        if (count > fat32_secperclus) count = fat32_secperclus;
        if (storage_write(sector, count, &((uint32_t*)buffer)[i << 9])) return 0;
        if ((count << 11) >= size)
        {
            fat32_buf2[lastidx & 0x1ff] = 0x0fffffff;
            if (storage_write(fat32_fatbase + lastsect, 1, fat32_buf2)) return 0;
            break;
        }
        size -= count << 11;
        buffer = (void*)((uint32_t)buffer + (count << 11));
        scanidx++;
    }
    return clusterchain;
}

void fat32_set_direntry(uint32_t* ptr, const char* filename, uint32_t filechain,
                        uint32_t filesize, uint32_t flags)
{
    memcpy(ptr, filename, 11);
    ((uint16_t*)ptr)[0xa] = filechain >> 16;
    ((uint8_t*)ptr)[0xb] = flags;
    ((uint16_t*)ptr)[0xa] = filechain >> 16;
    ((uint16_t*)ptr)[0xd] = filechain & 0xffff;
    ptr[7] = filesize;
}

uint32_t fat32_store_direntry(uint32_t dirchain, const char* filename,
                              uint32_t filechain, uint32_t filesize, uint32_t flags)
{
    uint32_t i, j;
    uint32_t lastidx;
    while (dirchain > 1 && dirchain < 0x0ffffff0)
    {
        uint32_t sector = (dirchain - 2) * fat32_secperclus + fat32_database;
        for (j = 0; j < fat32_secperclus; j++)
        {
            if (storage_read(sector + j, 1, fat32_buf1)) return 1;
            for (i = 0; i < 0x200; i += 8)
                if (((uint8_t*)fat32_buf1)[i << 2] == 0
                 || ((uint8_t*)fat32_buf1)[i << 2] == 0xe5)
                {
                    fat32_set_direntry(&fat32_buf1[i], filename, filechain, filesize, flags);
                    if (storage_write(sector + j, 1, fat32_buf1)) return 1;
                    return 0;
                }
        }
        uint32_t fatsector = fat32_fatbase + (dirchain >> 9);
        if (storage_read(fatsector, 1, fat32_buf1)) return 1;
        lastidx = dirchain;
        dirchain = fat32_buf1[(i << 9) + (dirchain & 0x1FF)];
    }
    uint32_t scanidx = 2;
    uint32_t scansect = 0xffffffff;
    while (scanidx < fat32_clustercount + 2)
    {
        if ((scanidx >> 9) != scansect)
        {
            scansect = scanidx >> 9;
            if (storage_read(fat32_fatbase + scansect, 1, fat32_buf1)) return 1;
        }
        if (!fat32_buf1[scanidx & 0x1ff]) break;
        scanidx++;
    }
    if (scanidx >= fat32_clustercount + 2) return 1;
    fat32_buf1[scanidx & 0x1ff] = 0x0fffffff;
    if (storage_write(fat32_fatbase + scansect, 1, fat32_buf1)) return 1;
    if (storage_read(fat32_fatbase + (lastidx >> 9), 1, fat32_buf1)) return 1;
    fat32_buf1[lastidx & 0x1ff] = scanidx;
    if (storage_write(fat32_fatbase + scansect, 1, fat32_buf1)) return 1;
    uint32_t sector = (scanidx - 2) * fat32_secperclus + fat32_database;
    for (i = 0; i < fat32_secperclus; i++)
    {
        memset(fat32_buf1, 0, 0x800);
        if (!i) fat32_set_direntry(fat32_buf1, filename, filechain, filesize, flags);
        if (storage_write(sector + i, 1, fat32_buf1)) return 1;
    }
    return 0;
}

uint32_t fat32_create_dir(uint32_t parent, const char* dirname)
{
    uint32_t i;
    uint32_t scanidx = 2;
    uint32_t scansect = 0xffffffff;
    while (scanidx < fat32_clustercount + 2)
    {
        if ((scanidx >> 9) != scansect)
        {
            scansect = scanidx >> 9;
            if (storage_read(fat32_fatbase + scansect, 1, fat32_buf1)) return 0;
        }
        if (!fat32_buf1[scanidx & 0x1ff]) break;
        scanidx++;
    }
    if (scanidx >= fat32_clustercount + 2) return 0;
    fat32_buf1[scanidx & 0x1ff] = 0x0fffffff;
    if (storage_write(fat32_fatbase + scansect, 1, fat32_buf1)) return 0;
    fat32_store_direntry(parent, dirname, scanidx, 0, 0x10);
    uint32_t sector = (scanidx - 2) * fat32_secperclus + fat32_database;
    for (i = 0; i < fat32_secperclus; i++)
    {
        memset(fat32_buf1, 0, 0x800);
        if (!i)
        {
            fat32_set_direntry(fat32_buf1, ".          ", scanidx, 0, 0x10);
            if (parent == fat32_rootdirclus) parent = 0;
            fat32_set_direntry(&fat32_buf1[8], "..         ", parent, 0, 0x10);
        }
        if (storage_write(sector + i, 1, fat32_buf1)) return 0;
    }
    return scanidx;
}

uint32_t fat32_read_file(const char* filename, uint32_t maxsize, void* buffer, uint32_t* filesize)
{
}

uint32_t fat32_get_partition_start()
{
    return fat32_startsector;
}

uint32_t fat32_init()
{
    uint32_t i;
    fat32_ok = 0;
    fat32_startsector = 0xFFFFFFFF;
    if (storage_init()) return 1;

    if (storage_read(0, 1, fat32_buf1)) return 1;

    if (*((uint16_t*)((uint32_t)fat32_buf1 + 0x1FE)) != 0xAA55)
    {
        return 1;
    }

    for (i = 0x1C2; i < 0x200; i += 0x10)
        if (((uint8_t*)fat32_buf1)[i] == 0xB)
        {
            fat32_startsector = *((uint16_t*)((uint32_t)fat32_buf1 + i + 4))
                              | (*((uint16_t*)((uint32_t)fat32_buf1 + i + 6)) << 16);
            break;
        }

    if (fat32_startsector == 0xFFFFFFFF
     && *((uint16_t*)((uint32_t)fat32_buf1 + 0x52)) == 0x4146
     && *((uint8_t*)((uint32_t)fat32_buf1 + 0x54)) == 0x54)
        fat32_startsector = 0;

    if (fat32_startsector == 0xFFFFFFFF) return 1;

    if (storage_read(fat32_startsector, 1, fat32_buf1)) return 1;

    if (*((uint16_t*)((uint32_t)fat32_buf1 + 0x1FE)) != 0xAA55) return 1;

    if (((uint8_t*)fat32_buf1)[0xB] != 0 || ((uint8_t*)fat32_buf1)[0xC] != 8) return 1;

    fat32_secperclus = ((uint8_t*)fat32_buf1)[0xD];
    uint32_t reserved = ((uint16_t*)fat32_buf1)[0x7];
    fat32_fatcount = ((uint8_t*)fat32_buf1)[0x10];

    if (((uint8_t*)fat32_buf1)[0x11] != 0) return 1;

    fat32_sectorcount = fat32_buf1[8];
    fat32_fatsize = fat32_buf1[9];

    if (((uint16_t*)fat32_buf1)[0x15] != 0) return 1;

    fat32_rootdirclus = fat32_buf1[0xB];

    fat32_clustercount = (fat32_sectorcount - reserved
                        - fat32_fatcount * fat32_fatsize) / fat32_secperclus;

    fat32_fatbase = fat32_startsector + reserved;
    fat32_database = fat32_fatbase + fat32_fatcount * fat32_fatsize;

    fat32_ok = 1;
    return 0;
}