src/bsp/lk/lib/aee/kdump_sd.c

/*
 * Copyright (c) 2018 MediaTek Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <malloc.h>
#include <platform/mtk_wdt.h>
#include <stdint.h>
#include <string.h>

#include "aee.h"
#include "kdump.h"
#include "kdump_sdhc.h"

#define PAGE_SIZE 4096

#define DEVICE_SECTOR_BYTES 512

FAT_Para m_bFATInfo;
uint32_t m_bLastFATPage;
struct aee_timer total_time;
static struct mrdump_dev *dumpdev;

LfnEntry g_LfnEntry = {
    0x41,                               // sequence number
    {'C','\0','E','\0','D','\0','u','\0','m','\0'},                     // name characters (five UTF-16 characters)
    0x0F,                               // attributes (always 0x0F)
    0x00,                               // reserved (alwyas 0x00)
    0xDF,                               // checksum of DOS file name
    {'p','\0','.','\0','k','\0','d','\0','m','\0','p','\0'},            // name characters (six UTF-16 characters)
    0x0000,                             // word of first cluster (always 0x0000)
    {'\0','\0',0xFF,0xFF}
};

DirEntry g_DirEntry = {
    {'C','E','D','U','M','P','~','1','K','D','M'},              // name
    0x20,                           // attr
    0x00,                           // NTflags
    0x00,                           // createdTimeMsec
    0x63E8,                         // createdTime
    0x2E21,                         // createdDate
    0x2E21,                         // lastAccessDate
    0x0000,                         // clusFirstHigh
    0x6490,                         // time
    0x2E21,                         // date
    0x0000,                         // clusFirst
    0x00000000                      // size
};

unsigned int OALGetTickCount(void)
{
    return 0 ;
}

static unsigned char ToLower(unsigned char c)
{
    if ((c >= 'A') && (c <= 'Z'))
        return c+ 'a' - 'A';
    else
        return c;
}

static bool Compare_sd(const uint8_t *a, const uint8_t *b, int length)
{
    while (length--) {
        if (ToLower(*a++) != ToLower(*b++))
            return false;
    }
    return true;
}

static uint32_t BytesToNum_sd(uint8_t *b, int bytes)
{
    uint32_t result = 0;
    int i;

    for (i = 0; i < bytes; i++) {
        result |= b[i] << (i << 3);
    }
    return result;
}

static bool fatfs_dev_read(struct mrdump_dev *dev, uint64_t sector_addr, uint8_t *pdBuf, int32_t blockLen)
{
    return dev->read(dev, sector_addr * DEVICE_SECTOR_BYTES, pdBuf, blockLen * DEVICE_SECTOR_BYTES);
}

static bool fatfs_dev_write(struct mrdump_dev *dev, uint64_t sector_addr, uint8_t *pdBuf, int32_t blockLen)
{
    return dev->write(dev, sector_addr * DEVICE_SECTOR_BYTES, pdBuf, blockLen * DEVICE_SECTOR_BYTES);
}

static void fatfs_commit_fat_entry(FileHandler *pFileHandler, int fat_offset, uint32_t value)
{
    if (m_bFATInfo.FileSysType == FAT_32) {
        pFileHandler->FATBuffer[fat_offset * 4] = (value) & 0xff;
        pFileHandler->FATBuffer[fat_offset * 4 + 1] = (value >> 8) & 0xff;
        pFileHandler->FATBuffer[fat_offset * 4 + 2] = (value >> 16) & 0xff;
        pFileHandler->FATBuffer[fat_offset * 4 + 3] = (value >> 24) & 0xff;
    } else {
        pFileHandler->FATBuffer[fat_offset * 2] = (value) & 0xff;
        pFileHandler->FATBuffer[fat_offset * 2 + 1] = (value >> 8) & 0xff;
    }
}

uint32_t FindBootPartition_sd(uint8_t *SectorBuffer)
{
    uint32_t PartitionStart;
    uint32_t PartitionTpye;
    PartitionTpye = BytesToNum_sd(SectorBuffer + 0x1c2, 1);
    PartitionStart = BytesToNum_sd(SectorBuffer + 0x1c6, 4);

    voprintf_debug("SDCard: PartitionStart=0x%x ,PartitionTpye=0x%x\n", PartitionStart, PartitionTpye);
    if (PartitionTpye == 5) {
        if (!fatfs_dev_read(dumpdev, PartitionStart,SectorBuffer,1)) {
            voprintf_debug("SDCard: can not find BootPosition! \n");
            return 0;
        }
        PartitionStart += BytesToNum_sd(SectorBuffer + 0x1c6, 4);
        voprintf_debug("SDCard: PartitionStart=0x%x\n", PartitionStart);
    }
    return PartitionStart;
}

bool ReadBootPartition_sd(uint8_t *SectorBuffer)
{
    m_bFATInfo.BPB_BytsPerSec = BytesToNum_sd(SectorBuffer+11, 2);
    m_bFATInfo.BPB_SecPerClus = BytesToNum_sd(SectorBuffer+13, 1);
    m_bFATInfo.BPB_RsvdSecCnt = BytesToNum_sd(SectorBuffer+14, 2);
    m_bFATInfo.BPB_NumFATs = BytesToNum_sd(SectorBuffer+16, 1);
    m_bFATInfo.BPB_FATSz = BytesToNum_sd(SectorBuffer+22, 2);
    if (m_bFATInfo.BPB_FATSz) {
        m_bFATInfo.FileSysType = FAT_16;
        m_bFATInfo.BPB_RootEntCnt = BytesToNum_sd(SectorBuffer+17, 2);
        m_bFATInfo.BPB_TotSec = BytesToNum_sd(SectorBuffer+19, 2);
        m_bFATInfo.BPB_RootClus = 0;
        voprintf_debug("SDCard: FilSysType = FAT16\n");
    } else {
        m_bFATInfo.FileSysType = FAT_32;
        m_bFATInfo.BPB_TotSec = BytesToNum_sd(SectorBuffer+32, 4);
        m_bFATInfo.BPB_FATSz = BytesToNum_sd(SectorBuffer+36, 4);
        m_bFATInfo.BPB_RootEntCnt = 0;
        m_bFATInfo.BPB_RootClus = BytesToNum_sd(SectorBuffer+44, 4);
        voprintf_debug("SDCard: FilSysType = FAT32\n");
    }

    voprintf_debug("SDCard: BPB_BytsPerSec = 0x%04x\n", m_bFATInfo.BPB_BytsPerSec);
    voprintf_debug("SDCard: BPB_SecPerClus = 0x%02x\n", m_bFATInfo.BPB_SecPerClus);
    voprintf_debug("SDCard: BPB_RsvdSecCnt = 0x%04x\n", m_bFATInfo.BPB_RsvdSecCnt);
    voprintf_debug("SDCard: BPB_NumFATs = 0x%02x\n", m_bFATInfo.BPB_NumFATs);
    voprintf_debug("SDCard: BPB_FATSz = 0x%08x\n", m_bFATInfo.BPB_FATSz);
    voprintf_debug("SDCard: BPB_RootClus = 0x%08x\n", m_bFATInfo.BPB_RootClus);
    voprintf_debug("SDCard: BPB_TotSec = 0x%08x\n", m_bFATInfo.BPB_TotSec);

    if ((PAGE_SIZE > m_bFATInfo.BPB_SecPerClus * m_bFATInfo.BPB_BytsPerSec) ||
            ((m_bFATInfo.BPB_SecPerClus * m_bFATInfo.BPB_BytsPerSec) % PAGE_SIZE != 0)) {
        voprintf_error("Can't support SDCard cluster bytes %d\n", m_bFATInfo.BPB_SecPerClus * m_bFATInfo.BPB_BytsPerSec);
        return false;
    }
    return true;
}

static bool Block0_is_BootSector(uint8_t *Ptr)
{
    uint32_t BytesPerSec = 0;
    uint32_t SecPerClus = 0;
    uint32_t BPB_Media = 0;

    BytesPerSec = BytesToNum_sd(Ptr + 11, 2);
    if (!((BytesPerSec == 512)||(BytesPerSec == 1024)||(BytesPerSec == 2048)||(BytesPerSec == 4096))) {
        voprintf_error("Unsupport sector size %d\n", BytesPerSec);
        return false;
    }
    SecPerClus = BytesToNum_sd(Ptr + 13, 1);
    if (!((SecPerClus == 1)||(SecPerClus == 2)||(SecPerClus == 4)||
            (SecPerClus == 8)||(SecPerClus == 16)||(SecPerClus == 32)||
            (SecPerClus == 64)||(SecPerClus == 128)) &&
            (SecPerClus * BytesPerSec <= 0x10000)) {
        voprintf_error("Unsupport cluster size %d\n", SecPerClus);
        return false;
    }
    BPB_Media = BytesToNum_sd(Ptr + 21, 1);
    if (!((BPB_Media == 0xF8)||(BPB_Media == 0xF0)||(BPB_Media == 0xF9)||
            (BPB_Media == 0xFA)||(BPB_Media == 0xFB)||(BPB_Media == 0xFC)||
            (BPB_Media == 0xFD)||(BPB_Media == 0xFE)||(BPB_Media == 0xFF))) {
        voprintf_error("Unsupport media descriptor %d\n", BPB_Media);
        return false;
    }

    return true;
}

bool GetBPBInfo_sd(uint8_t *Ptr)
{
    m_bFATInfo.BPB_BytsPerSec = 512;
    m_bFATInfo.BootStartSec = 0;

    //*pSectorPosition
    if (!fatfs_dev_read(dumpdev, m_bFATInfo.BootStartSec, Ptr, 1)) {
        voprintf_error("SDCard: can not find MBR\n");
        return false;
    }

    // Add support block0 is bootPartition
    if (Block0_is_BootSector(Ptr)) {
        m_bFATInfo.BootStartSec = 0;
    } else {
        m_bFATInfo.BootStartSec  = FindBootPartition_sd(Ptr);
        if (!fatfs_dev_read(dumpdev, m_bFATInfo.BootStartSec, Ptr, 1)) {
            voprintf_error("SDCard: can't find BootPosition\n");
            mrdump_status_error("SDCard: can't find BootPosition\n");
            return false;
        }
        if (!Block0_is_BootSector(Ptr)) {
            voprintf_error("SDCard: BPB sector dismatch FAT Spec\n");
            mrdump_status_error("SDCard: BPB sector dismatch FAT Spec\n");
            return false;
        }
    }
    if (!ReadBootPartition_sd(Ptr)) {
        voprintf_error("SDCard: can not Read BootPartition\n");
        mrdump_status_error("SDCard: can not Read BootPartition\n");
        return false;
    }

    m_bFATInfo.FATStartSec = m_bFATInfo.BootStartSec + m_bFATInfo.BPB_RsvdSecCnt;

    if (m_bFATInfo.FileSysType == FAT_32) {
        m_bFATInfo.ClusStartSec = m_bFATInfo.FATStartSec+(m_bFATInfo.BPB_NumFATs)*(m_bFATInfo.BPB_FATSz);
        m_bFATInfo.RootDirStartSec = m_bFATInfo.ClusStartSec + (m_bFATInfo.BPB_RootClus-2)*(m_bFATInfo.BPB_SecPerClus);
    } else {
        m_bFATInfo.RootDirStartSec = m_bFATInfo.FATStartSec+(m_bFATInfo.BPB_NumFATs)*(m_bFATInfo.BPB_FATSz);
        m_bFATInfo.ClusStartSec = m_bFATInfo.RootDirStartSec+32*m_bFATInfo.BPB_RootEntCnt/m_bFATInfo.BPB_BytsPerSec;
    }

    return true;
}

uint32_t FindFirstClusInFAT_sd(uint32_t StartClusNum, uint8_t *Ptr)
{
    uint32_t SectorNum;
    uint32_t NextClusterPosition;
    uint32_t BytsPerFAT;
    uint32_t BytsPerAdd;
    if (m_bFATInfo.FileSysType == FAT_32)
        BytsPerAdd = 4;//FAT32
    else
        BytsPerAdd = 2;//FAT16

    BytsPerFAT = m_bFATInfo.BPB_BytsPerSec/BytsPerAdd;

    m_bLastFATPage = StartClusNum/BytsPerFAT;
    SectorNum = m_bFATInfo.FATStartSec+m_bLastFATPage;
#ifdef SD_DATA_PRINT
    voprintf_verbose("SDCard: now FATSec = %d \n",SectorNum);
#endif
    if (!fatfs_dev_read(dumpdev, SectorNum, Ptr, 1)) {
        voprintf_error("SDCard: can not FindFirstClusInFAT_sd\n");
        // FIXME: this is not right, why return 0?
        return 0;
    }

    NextClusterPosition = BytesToNum_sd(Ptr+BytsPerAdd * (StartClusNum%BytsPerFAT), BytsPerAdd);
#ifdef SD_DATA_PRINT
    voprintf_verbose("SDCard: NextClusterPosition = %08x\n", NextClusterPosition);
#endif
    return NextClusterPosition;
}

uint32_t FindNextClusInFAT_sd(uint32_t StartClusNum, uint8_t *Ptr)
{
    uint32_t SectorNum;
    uint32_t NextClusterPosition;
    uint32_t BytsPerFAT;
    uint32_t BytsPerAdd;
    uint32_t TempPage;
    if (m_bFATInfo.FileSysType==FAT_32)
        BytsPerAdd = 4;//FAT32
    else
        BytsPerAdd = 2;//FAT16

    BytsPerFAT = m_bFATInfo.BPB_BytsPerSec/BytsPerAdd;
    TempPage = StartClusNum/BytsPerFAT;
    if (TempPage!=m_bLastFATPage) {
        SectorNum = m_bFATInfo.FATStartSec+TempPage;
#ifdef SD_DATA_PRINT
        DBGKDUMP_PRINTK("SDCard: now FATSec = %d \n",SectorNum);
#endif
        if (!fatfs_dev_read(dumpdev, SectorNum,Ptr,1)) {
            voprintf_error("SDCard: can not FindNextClusInFAT_sd! \n");
            // FIXME: this is not right, why return 0?
            return 0;
        }
        m_bLastFATPage=TempPage;
#if 0
        for (j=0; j<(int)m_bFATInfo.BPB_BytsPerSec; j++) {
            if ((j%16)==0) DBGKDUMP_PRINTK("i= 0x%04x    ",j);
            DBGKDUMP_PRINTK(" %02x ", Ptr[j]);
            if (((j+1)%16)==0) DBGKDUMP_PRINTK("     i= %d\n",j);
        }
#endif
    }
    NextClusterPosition=BytesToNum_sd(Ptr+BytsPerAdd*(StartClusNum%BytsPerFAT),BytsPerAdd);
#ifdef SD_DATA_PRINT
    DBGKDUMP_PRINTK("SDCard: NextClusterPosition = %08x \n",NextClusterPosition);
#endif
    return NextClusterPosition;
}

uint32_t FindFirstFreeClusInFAT_sd(FileHandler *pFileHandler)
{
    uint32_t i;
    uint32_t SectorNum;
    uint32_t FreeClusterNum;
    uint32_t value;
    uint32_t FATSector, FATOffset;
    uint32_t EntryPerSector;
    uint32_t BytsPerAdd;

    if (m_bFATInfo.FileSysType==FAT_32)
        BytsPerAdd = 4;//FAT32
    else
        BytsPerAdd = 2;//FAT16

    FreeClusterNum = 0;
    EntryPerSector = m_bFATInfo.BPB_BytsPerSec/BytsPerAdd;
    FATSector = pFileHandler->CurrClusterNum/EntryPerSector;
    FATOffset = pFileHandler->CurrClusterNum%EntryPerSector + 1;     // start search frome next cluster

    // for safty, we don't use all FAT entries, just reserve the last FAT sector
    while (FATSector < (m_bFATInfo.BPB_FATSz-1)) {
        // Read new FAT sector to cache
        SectorNum = m_bFATInfo.FATStartSec+FATSector;
        if (!fatfs_dev_read(dumpdev, SectorNum, pFileHandler->FATBuffer, 1)) {
            voprintf_error("SDCard: %s read failed\n", __func__);
            return 0;
        }

        for (i=FATOffset; i<EntryPerSector; i++) {
            value = BytesToNum_sd(pFileHandler->FATBuffer+i*BytsPerAdd, BytsPerAdd);
            if (value == 0) {
                FreeClusterNum = FATSector*EntryPerSector + i;  // found free entry in FAT
                pFileHandler->FATSector = FATSector;
                return FreeClusterNum;
            }
        }
        // try next FAT sector
        FATSector++;
        FATOffset = 0;
    }

    return 0;
}

uint32_t ChainFreeClusInFAT_sd(FileHandler *pFileHandler)
{
    uint32_t i;
    uint32_t SectorNum;
    uint32_t FreeClusterNum;
    uint32_t value;
    uint32_t CurrFATSector, CurrFATOffset;
    uint32_t NextFATSector, NextFATOffset;
    uint32_t EntryPerSector;
    uint32_t BytsPerAdd;
    uint8_t  TempFAT[512];
    uint8_t  *pBuf;

    if (m_bFATInfo.FileSysType==FAT_32)
        BytsPerAdd = 4;//FAT32
    else
        BytsPerAdd = 2;//FAT16

    FreeClusterNum = 0;
    EntryPerSector = m_bFATInfo.BPB_BytsPerSec/BytsPerAdd;
    CurrFATSector = pFileHandler->CurrClusterNum/EntryPerSector;
    CurrFATOffset = pFileHandler->CurrClusterNum%EntryPerSector;
    NextFATSector = CurrFATSector;
    NextFATOffset = CurrFATOffset+1;    // start search frome next cluster
    memset(TempFAT,0,512);

    pBuf = pFileHandler->FATBuffer;
    // for safty, we don't use all FAT entries, just reserve the last FAT sector
    while (NextFATSector < (m_bFATInfo.BPB_FATSz-1)) {
        if (NextFATSector != pFileHandler->FATSector) {
            // FAT sector changed, read new FAT sector to temp buffer
            pBuf = TempFAT;
            SectorNum = m_bFATInfo.FATStartSec+NextFATSector;
            if (!fatfs_dev_read(dumpdev, SectorNum, pBuf, 1)) {
                voprintf_error("SDCard: %s read failed\n", __func__);
                return 0;
            }
        }
        // find free cluster in FAT cache
        for (i=NextFATOffset; i<EntryPerSector; i++) {
            value = BytesToNum_sd(pBuf+i*BytsPerAdd, BytsPerAdd);
            if (value == 0) {
                FreeClusterNum = NextFATSector*EntryPerSector + i;  // found free entry in FAT
                // commit FAT entry
                fatfs_commit_fat_entry(pFileHandler, CurrFATOffset, FreeClusterNum);
                break;
            }
        }

        if (FreeClusterNum!=0) {
            break;
        }

        // try next FAT sector
        NextFATSector++;
        NextFATOffset = 0;
    }

    // check if need to refresh cache
    if ((FreeClusterNum != 0) && (NextFATSector != pFileHandler->FATSector)) {
        // FAT sector changed, flush cache to SD
        SectorNum = m_bFATInfo.FATStartSec+CurrFATSector;
        if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FATBuffer, 1)) {
            voprintf_error("SDCard: %s write failed\n", __func__);
            return 0;
        }

        // copy temp buffer to cache
        memcpy(pFileHandler->FATBuffer, TempFAT, 512);
        pFileHandler->FATSector = NextFATSector;
    }

    return FreeClusterNum;
}

bool MarkEndClusInFAT_sd(FileHandler *pFileHandler)
{
    uint32_t SectorNum;
    uint32_t BytsPerAdd;
    uint32_t EntryPerSector;
    uint32_t FATSector;
    uint32_t FATOffset;

    if (m_bFATInfo.FileSysType==FAT_32)
        BytsPerAdd = 4;//FAT32
    else
        BytsPerAdd = 2;//FAT16

    EntryPerSector = m_bFATInfo.BPB_BytsPerSec/BytsPerAdd;
    FATSector = pFileHandler->CurrClusterNum/EntryPerSector;
    FATOffset = pFileHandler->CurrClusterNum%EntryPerSector;
    SectorNum = m_bFATInfo.FATStartSec+FATSector;

    if (FATSector != pFileHandler->FATSector) {
        if (!fatfs_dev_read(dumpdev, SectorNum, pFileHandler->FATBuffer, 1)) {
            voprintf_error("SDCard: MarkEndClusInFAT_sd dumpdev->read failed\n");
            return false;
        }
    }

    fatfs_commit_fat_entry(pFileHandler, FATOffset, 0xffffffff);

    // flush FAT cache to SD
    if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FATBuffer, 1)) {
        voprintf_error("SDCard: MarkEndClusInFAT_sd dumpdev->write failed\n");
        return false;
    }
    return true;
}

bool DeleteFileInFAT_sd(FileHandler *pFileHandler)
{
    uint32_t StartClusNum;
    uint32_t SectorNum;
    uint32_t NextClusNum;
    uint32_t FATSector, FATOffset;
    uint32_t EntryPerSector;
    uint32_t BytsPerAdd;
    bool NewSector = true;
    bool LastEntry = false;

    if (m_bFATInfo.FileSysType == FAT_32) {
        BytsPerAdd = 4;//FAT32
    } else {
        BytsPerAdd = 2;//FAT16
    }

    EntryPerSector = m_bFATInfo.BPB_BytsPerSec/BytsPerAdd;
    StartClusNum = pFileHandler->CurrClusterNum;
    SectorNum = m_bFATInfo.FATStartSec+StartClusNum/EntryPerSector;

    while (!LastEntry) {
        FATSector = StartClusNum/EntryPerSector;
        FATOffset = StartClusNum%EntryPerSector;

        if (NewSector) {
            SectorNum = m_bFATInfo.FATStartSec+FATSector;
#ifdef SD_DATA_PRINT
            DBGKDUMP_PRINTK("SDCard: now FATSec = %d \n",SectorNum);
#endif
            if (!fatfs_dev_read(dumpdev, SectorNum, pFileHandler->FATBuffer, 1)) {
                voprintf_error("SDCard: DeleteFile_sd read failed\n");
                return false;
            }
            NewSector = false;
        }

        NextClusNum = BytesToNum_sd(pFileHandler->FATBuffer+FATOffset*BytsPerAdd, BytsPerAdd);

        fatfs_commit_fat_entry(pFileHandler, FATOffset, 0x0);
        // Release FAT entry
        if (m_bFATInfo.FileSysType==FAT_32) {

            if ((NextClusNum >= 0xFFFFFF8) || (NextClusNum == 0)) {
                LastEntry = true;
            }
        } else {
            if ((NextClusNum >= 0xFFF8) || (NextClusNum == 0)) {
                LastEntry = true;
            }
        }

        if (NextClusNum/EntryPerSector != FATSector) {
            NewSector = true;   // next cluster is not at current FAT Sector, write current FAT sector back
        }

        if (NewSector || LastEntry) {
            if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FATBuffer, 1)) {
                voprintf_error("SDCard: DeleteFile_sd write failed\n");
                return false;
            }
        }

        StartClusNum = NextClusNum;
    }

#ifdef SD_DATA_PRINT
    DBGKDUMP_PRINTK("SDCard: NextClusterPosition = %08x \n",NextClusterPosition);
#endif

    return true;
}

static bool OpenDumpFile_sd(FileHandler *pFileHandler)
{
    int i, j, times;
    uint32_t SectorNum;
    uint32_t Temp;
    uint32_t dwStartTick;
    uint32_t FindFile_TIMEOUT = 60000;
    int SecLen;
    uint32_t NextRootFAT = 0;
    uint8_t RootDirFAT[512];
    bool foundLfn = false;

    // init File Handler
    memset(pFileHandler, 0, sizeof(FileHandler));
    if (!GetBPBInfo_sd(pFileHandler->FileBuffer)) {
        return false;
    }

    dwStartTick = OALGetTickCount();

    voprintf_debug("SDCard: FATStartSec=%d RootdirStartSec=%d\n", m_bFATInfo.FATStartSec, m_bFATInfo.RootDirStartSec);
    SectorNum = m_bFATInfo.RootDirStartSec;
    if (m_bFATInfo.FileSysType == FAT_16) {
        SecLen=32;
        times=1;
    } else {
        SecLen = m_bFATInfo.BPB_SecPerClus;
        times=MaxFindFileClusNum;
    }

    while (times) {
        for (i = 0; i < SecLen; i++) {
            if (!fatfs_dev_read(dumpdev, SectorNum, pFileHandler->FileBuffer, 1)) {
                voprintf_error("SDCard: can not read RootDir!\n");
                return false;
            }

            for (j=0; j<(int)m_bFATInfo.BPB_BytsPerSec; j+=32) {
                if (foundLfn) {
                    Temp = BytesToNum_sd(pFileHandler->FileBuffer+j+20, 2);
                    pFileHandler->CurrClusterNum |= (Temp<<16);
                    Temp = BytesToNum_sd(pFileHandler->FileBuffer+j+26, 2);
                    pFileHandler->CurrClusterNum |= (Temp&0xFFFF);

                    // delete file DIR entries
                    memset(pFileHandler->FileBuffer+j, 0, 32);
                    if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FileBuffer, 1)) {
                        voprintf_error("SDCard: can not write directory entry!\n");
                        return false;
                    }
                    // delete file in FAT entries
                    if (!DeleteFileInFAT_sd(pFileHandler)) {
                        voprintf_error("SDCard: can not delete file in FAT entries!\n");
                        return false;
                    }
                    goto Done;
                } else if (pFileHandler->FileBuffer[j] == 0x41 &&
                           Compare_sd(pFileHandler->FileBuffer+j+1, g_LfnEntry.name1, 10) &&
                           Compare_sd(pFileHandler->FileBuffer+j+14, g_LfnEntry.name2, 12)) {
#if 0
                    // delete LFN entries
                    memset(pFileHandler->FileBuffer+j, 0, 32);
                    if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FileBuffer, 1)) {
                        voprintf_error("SDCard: can not write LFN entry!\n");
                        return false;
                    }
                    foundLfn = true;
#else
                    voprintf_error("SDCard: dump file exist, skip dumping\n");
                    mrdump_status_error("File exist at SDCARD, skip dumping\n");
                    return false;
#endif
                }
            }
            SectorNum+=1;
        }
        if ((OALGetTickCount() - dwStartTick) >= FindFile_TIMEOUT) {
            voprintf_error("SDCard: Find File timeout\n");
            return false;
        }
        if (m_bFATInfo.FileSysType==FAT_32) {
            if (times==MaxFindFileClusNum) {
                NextRootFAT=FindFirstClusInFAT_sd(m_bFATInfo.BPB_RootClus, RootDirFAT);
                if (NextRootFAT>=0xFFFFFF8) {
                    break;
                }
            } else {
                NextRootFAT=FindNextClusInFAT_sd(NextRootFAT, RootDirFAT);
                if (NextRootFAT >= 0xFFFFFF8) {
                    break;
                }
            }
            voprintf_info("SDCard: NextRootFAT=0x%08x  \n", NextRootFAT);
            SectorNum=m_bFATInfo.ClusStartSec + (NextRootFAT-2)*(m_bFATInfo.BPB_SecPerClus);
        } else {
            // FAT16
            break;
        }
        times--;
    }

Done:
    // return a free cluster to create new file
    pFileHandler->CurrClusterNum = 2;
    pFileHandler->CurrClusterNum = FindFirstFreeClusInFAT_sd(pFileHandler);
    pFileHandler->PrevClusterNum = pFileHandler->CurrClusterNum;
    g_DirEntry.clusFirstHigh = (uint16_t)((pFileHandler->CurrClusterNum >> 16) & 0xFFFF);
    g_DirEntry.clusFirst = (uint16_t)(pFileHandler->CurrClusterNum & 0xFFFF);
    if (!pFileHandler->CurrClusterNum) {
        pFileHandler->DiskFull = true;
        voprintf_error("SDCard full, not free space available at create file\n");
        mrdump_status_error("SDCard full, not free space available at create file\n");
        return false;
    }

    voprintf_debug("%s: ok\n", __func__);
    return true;
}

bool UpdateDirectoryEntry_sd(FileHandler *pFileHandler)
{
    int i, j, times;
    uint32_t SectorNum;
    uint32_t dwStartTick;
    uint32_t FindFile_TIMEOUT = 60000;
    int SecLen;
    uint32_t NextRootFAT = 0;
    uint8_t RootDirFAT[512];

    dwStartTick = OALGetTickCount();
    voprintf_info("SDCard: FATStartSec = %d \n",m_bFATInfo.FATStartSec);
    voprintf_info("SDCard: RootDirStartSec = %d \n", m_bFATInfo.RootDirStartSec);
    SectorNum = m_bFATInfo.RootDirStartSec;

    if (m_bFATInfo.FileSysType==FAT_16) {
        SecLen=32;
        times=1;
    } else {
        SecLen = m_bFATInfo.BPB_SecPerClus;
        times=MaxFindFileClusNum;
    }

    while (times) {
        for (i = 0; i < SecLen; i++) {
            if (!fatfs_dev_read(dumpdev, SectorNum, pFileHandler->FileBuffer, 1)) {
                voprintf_error("SDCard: can not read RootDir!\n");
                return false;
            }

            for (j = 0; j < (int)(m_bFATInfo.BPB_BytsPerSec - 32); j += 32) {
                if ((pFileHandler->FileBuffer[j] == 0x0 || pFileHandler->FileBuffer[j] == 0xE5) &&
                        (pFileHandler->FileBuffer[j+32] == 0x0 || pFileHandler->FileBuffer[j+32] == 0xE5)) {
                    memcpy(pFileHandler->FileBuffer+j, &g_LfnEntry, sizeof(LfnEntry));
                    memcpy(pFileHandler->FileBuffer+j+32, &g_DirEntry, sizeof(DirEntry));

                    if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FileBuffer, 1)) {
                        voprintf_error("SDCard: can not read RootDir! \n");
                        return false;
                    }
                    return true;
                }
            }
            SectorNum += 1;
        }
        if ((OALGetTickCount() - dwStartTick) >= FindFile_TIMEOUT) {
            voprintf_error("SDCard: Find File Error timeout\n");
            return false;
        }
        if (m_bFATInfo.FileSysType==FAT_32) {
            if (times == MaxFindFileClusNum) {
                NextRootFAT=FindFirstClusInFAT_sd(m_bFATInfo.BPB_RootClus, RootDirFAT);
                if (NextRootFAT>=0xFFFFFF8) {
                    voprintf_error("SDCard: Dump file not exsited.\n");
                    break;
                }
            } else {
                NextRootFAT=FindNextClusInFAT_sd(NextRootFAT, RootDirFAT);
                if (NextRootFAT>=0xFFFFFF8) {
                    voprintf_error("SDCard: Dump file not exsited.\n");
                    break;
                }
            }
            voprintf_error("SDCard: NextRootFAT=0x%08x  \n", NextRootFAT);
            SectorNum=m_bFATInfo.ClusStartSec + (NextRootFAT-2)*(m_bFATInfo.BPB_SecPerClus);
        } else {
            // FAT16
            break;
        }
        times--;
    }

    return false;
}

static bool WriteDumpFile_sd(FileHandler *pFileHandler, uint8_t *Ptr, uint32_t Length, uint32_t Total)
{
    uint32_t i;
    uint32_t SectorNum;
    uint32_t FreeClusterNum;
    uint8_t val;

    uint32_t ClusterSize = m_bFATInfo.BPB_SecPerClus * m_bFATInfo.BPB_BytsPerSec;

    while (Length > 0) {
        // for every cluster boundary, check disk free space
        if (pFileHandler->DiskFull) {
            return false;
        }

        for (i = pFileHandler->BufferLen; (i < ClusterSize) && (Length > 0); i++) {
            val = *Ptr++;
            pFileHandler->FileBuffer[pFileHandler->BufferLen++] = val;
            pFileHandler->CheckSum += val;
            pFileHandler->TotalLen++;
            Length--;
        }

        // a cluster collected, flush to SD
        if (pFileHandler->BufferLen == ClusterSize) {
            pFileHandler->BufferLen = 0;
            SectorNum=m_bFATInfo.ClusStartSec + (pFileHandler->CurrClusterNum-2)*(m_bFATInfo.BPB_SecPerClus);
            //DBGKDUMP_PRINTK("SDCard: WriteDumpFile_sd() write sd card from %d blocks!\n",SectorNum);

            if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FileBuffer, m_bFATInfo.BPB_SecPerClus)) {
                voprintf_error("SDCard: WriteDumpFile_sd() write file content from %d blocks failed!!!!\n",SectorNum);
                return false;
            }

            pFileHandler->PrevClusterNum = pFileHandler->CurrClusterNum;
            FreeClusterNum =  ChainFreeClusInFAT_sd(pFileHandler);
            if (FreeClusterNum == 0) {
                pFileHandler->DiskFull = true;
                voprintf_error("SDcard full, no free space available\n");
                mrdump_status_error("SDcard full, no free space available\n");
                return false;
            }
            pFileHandler->CurrClusterNum =FreeClusterNum;
        } else if (pFileHandler->BufferLen > ClusterSize) {
            voprintf_error("SDCard: WriteDumpFile_sd() BufferLen error!\n");
        }
    }

    return true;
}

static bool CloseDumpFile_sd(FileHandler *pFileHandler)
{
    uint32_t SectorNum;

    g_DirEntry.size = pFileHandler->TotalLen;

#if 0
    uint16_t year;
    g_DirEntry.createdTime = g_DirEntry.time = (((INREG16(&m_pRTCRegs->RTC_TC_HOU) << 11) & 0xF800) |
                             ((INREG16(&m_pRTCRegs->RTC_TC_MIN) << 5) & 0x7E0) |
                             ((INREG16(&m_pRTCRegs->RTC_TC_SEC)>>1) & 0x1F));
    year = INREG16(&m_pRTCRegs->RTC_TC_YEA);
    year = (year > 20) ? (year-20) : 0;
    g_DirEntry.createdDate = g_DirEntry.date = (((year<<9) & 0xFE00) |
                             ((INREG16(&m_pRTCRegs->RTC_TC_MTH)<<5) & 0x1E0) |
                             (INREG16(&m_pRTCRegs->RTC_TC_DOM) & 0x1F));
#endif
    g_DirEntry.createdTime = g_DirEntry.time = 0;
    g_DirEntry.createdDate = g_DirEntry.date = 0;

    if (pFileHandler->BufferLen == 0) {
        // the free cluster is not used, so that the last cluster should be the previous one
        pFileHandler->CurrClusterNum = pFileHandler->PrevClusterNum;
    } else if (!pFileHandler->DiskFull) {
        // flush the reset data
        SectorNum=m_bFATInfo.ClusStartSec + (pFileHandler->CurrClusterNum-2)*(m_bFATInfo.BPB_SecPerClus);
        if (!fatfs_dev_write(dumpdev, SectorNum, pFileHandler->FileBuffer, m_bFATInfo.BPB_SecPerClus)) {
            voprintf_error("SDCard: CloseFile_sd() write file content failed!\n");
            return false;
        }
    }

    if (!MarkEndClusInFAT_sd(pFileHandler)) {
        voprintf_error("SDCard: CloseFile_sd() MarkEndClusInFAT_sd failed!\n");
        return false;
    }

    if (!UpdateDirectoryEntry_sd(pFileHandler)) {
        voprintf_error("SDCard: CloseFile_sd() UpdateDirectoryEntry_sd failed!\n");
        return false;
    }

    return true;
}

static int sd_write_cb(void *handle, void *buf, int size)
{
    if (WriteDumpFile_sd(handle, buf, size, 0)) {
        return size;
    } else {
        return 0;
    }
}

int mrdump_vfat_output(const struct mrdump_control_block *mrdump_cb, const struct kzip_addlist *memlist, struct mrdump_dev *mrdump_dev)
{
    if (mrdump_dev == NULL) {
        return -1;
    }

    dumpdev = mrdump_dev;
    voprintf_info("Output to VFAT Partition %s\n", dumpdev->name);

    FileHandler *file_handle = memalign(16, sizeof(FileHandler));
    if (file_handle == NULL) {
        voprintf_error("No enough memory.");
        return -1;
    }
    memset(file_handle, 0, sizeof(FileHandler));

    mtk_wdt_restart();
    bool ok = true;
    if (OpenDumpFile_sd(file_handle)) {
        mtk_wdt_restart();
        struct kzip_file *zf = kzip_open(file_handle, sd_write_cb);
        if (zf != NULL) {
            if (!kzip_add_file(zf, memlist, "SYS_COREDUMP")) {
                ok = false;
            }
            kzip_close(zf);
            zf = NULL;
        } else {
            ok = false;
        }

        mtk_wdt_restart();
        CloseDumpFile_sd(file_handle);
        free(file_handle);

        if (ok) {
            mrdump_status_ok("OUTPUT:%s\nMODE:%s\n", "VFAT_INT_STORAGE", mrdump_mode2string(mrdump_cb->crash_record.reboot_mode));
        }
    }

    return ok ? 0 : -1;
}