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