| Line 26... |
Line 26... |
#include <string.h>
|
#include <string.h>
|
#define _LIBC
|
#define _LIBC
|
#endif
|
#endif
|
#include "rtos.h"
|
#include "rtos.h"
|
|
|
|
#define FLASH_SIZE 1024*1024*16
|
|
#define FLASH_SECTOR_SIZE 1024*128
|
|
#define FLASH_BLOCK_SIZE 512
|
|
#define FLASH_LN2_SIZE 9 //2^FLASH_LN2_SIZE == FLASH_BLOCK_SIZE
|
|
#define FLASH_OFFSET FLASH_SECTOR_SIZE //offset to start of flash file system
|
|
|
#define BLOCK_SIZE 512
|
#define BLOCK_SIZE 512
|
#define FILE_NAME_SIZE 40
|
#define FILE_NAME_SIZE 40
|
#define FULL_NAME_SIZE 128
|
#define FULL_NAME_SIZE 128
|
#define BLOCK_MALLOC 0x0
|
#define BLOCK_MALLOC 0x0
|
#define BLOCK_EOF 0xffffffff
|
#define BLOCK_EOF 0xffffffff
|
| Line 86... |
Line 92... |
void OS_fdelete(char *name);
|
void OS_fdelete(char *name);
|
|
|
|
|
/***************** Media Functions Start ***********************/
|
/***************** Media Functions Start ***********************/
|
#ifdef INCLUDE_FLASH
|
#ifdef INCLUDE_FLASH
|
#define FLASH_BASE 1024*128
|
#define FLASH_BLOCKS FLASH_SIZE/FLASH_BLOCK_SIZE
|
#define FLASH_BLOCKS 1024*1024*16/BLOCK_SIZE
|
#define FLASH_START (FLASH_OFFSET+FLASH_BLOCKS/8*2)/FLASH_BLOCK_SIZE
|
#define FLASH_OFFSET (FLASH_BASE+FLASH_BLOCKS/8*2)/BLOCK_SIZE
|
|
static unsigned char FlashBlockEmpty[FLASH_BLOCKS/8];
|
static unsigned char FlashBlockEmpty[FLASH_BLOCKS/8];
|
static unsigned char FlashBlockUsed[FLASH_BLOCKS/8];
|
static unsigned char FlashBlockUsed[FLASH_BLOCKS/8];
|
static int FlashOffset;
|
static int FlashBlock;
|
|
|
|
|
//Free unused flash blocks
|
//Free unused flash blocks
|
static int MediaBlockCleanup(void)
|
static int MediaBlockCleanup(void)
|
{
|
{
|
int i, j, k, count=0;
|
int i, sector, block, count=0;
|
unsigned char *buf;
|
unsigned char *buf;
|
|
|
printf("FlashCleanup\n");
|
printf("FlashCleanup\n");
|
buf = (unsigned char*)malloc(1024*128);
|
buf = (unsigned char*)malloc(FLASH_SECTOR_SIZE);
|
if(buf == NULL)
|
if(buf == NULL)
|
return 0;
|
return 0;
|
for(j = 1; j < 128; ++j)
|
for(sector = FLASH_OFFSET / FLASH_SECTOR_SIZE; sector < FLASH_SIZE / FLASH_SECTOR_SIZE; ++sector)
|
{
|
{
|
FlashRead((uint16*)buf, 1024*128*j, 1024*128);
|
FlashRead((uint16*)buf, FLASH_SECTOR_SIZE*sector, FLASH_SECTOR_SIZE);
|
if(j == 1)
|
if(sector == FLASH_OFFSET)
|
{
|
{
|
for(i = 0; i < FLASH_BLOCKS/8; ++i)
|
for(i = 0; i < FLASH_BLOCKS/8; ++i)
|
FlashBlockEmpty[i] |= ~FlashBlockUsed[i];
|
FlashBlockEmpty[i] |= ~FlashBlockUsed[i];
|
memcpy(buf, FlashBlockEmpty, sizeof(FlashBlockEmpty));
|
memcpy(buf, FlashBlockEmpty, sizeof(FlashBlockEmpty));
|
memset(FlashBlockUsed, 0xff, sizeof(FlashBlockUsed));
|
memset(FlashBlockUsed, 0xff, sizeof(FlashBlockUsed));
|
memset(buf+sizeof(FlashBlockEmpty), 0xff, sizeof(FlashBlockUsed));
|
memset(buf+sizeof(FlashBlockEmpty), 0xff, sizeof(FlashBlockUsed));
|
}
|
}
|
//Erase empty blocks
|
//Erase empty blocks
|
for(k = 0; k < 256; ++k)
|
for(block = 0; block < FLASH_SECTOR_SIZE / FLASH_BLOCK_SIZE; ++block)
|
{
|
{
|
i = j*256 + k;
|
i = sector * FLASH_SECTOR_SIZE / FLASH_BLOCK_SIZE + block;
|
if(FlashBlockEmpty[i >> 3] & (1 << (i & 7)))
|
if(FlashBlockEmpty[i >> 3] & (1 << (i & 7)))
|
{
|
{
|
memset(buf + BLOCK_SIZE*k, 0xff, BLOCK_SIZE);
|
memset(buf + FLASH_BLOCK_SIZE*block, 0xff, FLASH_BLOCK_SIZE);
|
++count;
|
++count;
|
}
|
}
|
}
|
}
|
FlashErase(1024*128*j);
|
FlashErase(FLASH_SECTOR_SIZE * sector);
|
FlashWrite((uint16*)buf, 1024*128*j, 1024*128);
|
FlashWrite((uint16*)buf, FLASH_SECTOR_SIZE * sector, FLASH_SECTOR_SIZE);
|
}
|
}
|
free(buf);
|
free(buf);
|
return count;
|
return count;
|
}
|
}
|
|
|
|
|
int MediaBlockInit(void)
|
int MediaBlockInit(void)
|
{
|
{
|
FlashRead((uint16*)FlashBlockEmpty, FLASH_BASE, sizeof(FlashBlockEmpty));
|
FlashRead((uint16*)FlashBlockEmpty, FLASH_OFFSET, sizeof(FlashBlockEmpty));
|
FlashRead((uint16*)FlashBlockUsed, FLASH_BASE+4096, sizeof(FlashBlockUsed));
|
FlashRead((uint16*)FlashBlockUsed, FLASH_OFFSET+sizeof(FlashBlockEmpty),
|
FlashOffset = FLASH_OFFSET;
|
sizeof(FlashBlockUsed));
|
return FlashBlockEmpty[FlashOffset >> 3] & (1 << (FlashOffset & 7));
|
FlashBlock = FLASH_START;
|
|
return FlashBlockEmpty[FlashBlock >> 3] & (1 << (FlashBlock & 7));
|
}
|
}
|
#endif
|
#endif
|
|
|
|
|
static uint32 MediaBlockMalloc(OS_FILE *file)
|
static uint32 MediaBlockMalloc(OS_FILE *file)
|
| Line 152... |
Line 157... |
|
|
if(file->fileEntry.mediaType == FILE_MEDIA_RAM)
|
if(file->fileEntry.mediaType == FILE_MEDIA_RAM)
|
return (uint32)malloc(file->fileEntry.blockSize);
|
return (uint32)malloc(file->fileEntry.blockSize);
|
#ifdef INCLUDE_FLASH
|
#ifdef INCLUDE_FLASH
|
//Find empty flash block
|
//Find empty flash block
|
for(i = FlashOffset; i < FLASH_BLOCKS; ++i)
|
for(i = FlashBlock; i < FLASH_BLOCKS; ++i)
|
{
|
{
|
if(FlashBlockEmpty[i >> 3] & (1 << (i & 7)))
|
if(FlashBlockEmpty[i >> 3] & (1 << (i & 7)))
|
{
|
{
|
FlashOffset = i + 1;
|
FlashBlock = i + 1;
|
FlashBlockEmpty[i >> 3] &= ~(1 << (i & 7));
|
FlashBlockEmpty[i >> 3] &= ~(1 << (i & 7));
|
j = i >> 3;
|
j = i >> 3;
|
j &= ~1;
|
j &= ~1;
|
FlashWrite((uint16*)(FlashBlockEmpty + j), FLASH_BASE + j, 2);
|
FlashWrite((uint16*)(FlashBlockEmpty + j), FLASH_OFFSET + j, 2);
|
return i;
|
return i;
|
}
|
}
|
}
|
}
|
|
|
i = MediaBlockCleanup();
|
i = MediaBlockCleanup();
|
if(i == 0)
|
if(i == 0)
|
return 0;
|
return 0;
|
FlashOffset = FLASH_OFFSET;
|
FlashBlock = FLASH_START;
|
return MediaBlockMalloc(file);
|
return MediaBlockMalloc(file);
|
#else
|
#else
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
| Line 187... |
Line 192... |
{
|
{
|
int i=blockIndex, j;
|
int i=blockIndex, j;
|
FlashBlockUsed[i >> 3] &= ~(1 << (i & 7));
|
FlashBlockUsed[i >> 3] &= ~(1 << (i & 7));
|
j = i >> 3;
|
j = i >> 3;
|
j &= ~1;
|
j &= ~1;
|
FlashWrite((uint16*)(FlashBlockUsed + j), FLASH_BASE + sizeof(FlashBlockEmpty) + j, 2);
|
FlashWrite((uint16*)(FlashBlockUsed + j), FLASH_OFFSET + sizeof(FlashBlockEmpty) + j, 2);
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
|
|
| Line 201... |
Line 206... |
file->block = (OS_Block_t*)blockIndex;
|
file->block = (OS_Block_t*)blockIndex;
|
#ifdef INCLUDE_FLASH
|
#ifdef INCLUDE_FLASH
|
else
|
else
|
{
|
{
|
if(file->blockLocal == NULL)
|
if(file->blockLocal == NULL)
|
file->blockLocal = (OS_Block_t*)malloc(BLOCK_SIZE);
|
file->blockLocal = (OS_Block_t*)malloc(FLASH_BLOCK_SIZE);
|
file->block = file->blockLocal;
|
file->block = file->blockLocal;
|
FlashRead((uint16*)file->block, blockIndex << 9, BLOCK_SIZE);
|
FlashRead((uint16*)file->block, blockIndex << FLASH_LN2_SIZE, FLASH_BLOCK_SIZE);
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
|
|
| Line 215... |
Line 220... |
{
|
{
|
(void)file;
|
(void)file;
|
(void)blockIndex;
|
(void)blockIndex;
|
#ifdef INCLUDE_FLASH
|
#ifdef INCLUDE_FLASH
|
if(file->fileEntry.mediaType != FILE_MEDIA_RAM)
|
if(file->fileEntry.mediaType != FILE_MEDIA_RAM)
|
FlashWrite((uint16*)file->block, blockIndex << 9, BLOCK_SIZE);
|
FlashWrite((uint16*)file->block, blockIndex << FLASH_LN2_SIZE, FLASH_BLOCK_SIZE);
|
#endif
|
#endif
|
}
|
}
|
|
|
/***************** Media Functions End *************************/
|
/***************** Media Functions End *************************/
|
|
|
| Line 490... |
Line 495... |
file = OS_fopen("flash", "w+");
|
file = OS_fopen("flash", "w+");
|
if(file == NULL)
|
if(file == NULL)
|
return NULL;
|
return NULL;
|
file->fileEntry.isDirectory = 1;
|
file->fileEntry.isDirectory = 1;
|
file->fileEntry.mediaType = FILE_MEDIA_FLASH;
|
file->fileEntry.mediaType = FILE_MEDIA_FLASH;
|
|
file->fileEntry.blockSize = FLASH_BLOCK_SIZE;
|
file->blockLocal = file->block;
|
file->blockLocal = file->block;
|
file->block = NULL;
|
file->block = NULL;
|
rc = MediaBlockInit();
|
rc = MediaBlockInit();
|
if(rc == 1)
|
if(rc == 1)
|
BlockRead(file, BLOCK_MALLOC);
|
BlockRead(file, BLOCK_MALLOC);
|
else
|
else
|
BlockRead(file, FLASH_OFFSET);
|
BlockRead(file, FLASH_START);
|
file->fileEntry.blockIndex = file->blockIndex;
|
file->fileEntry.blockIndex = file->blockIndex;
|
OS_fclose(file);
|
OS_fclose(file);
|
#endif
|
#endif
|
}
|
}
|
|
|
