838 lines
20 KiB
C
Executable File
838 lines
20 KiB
C
Executable File
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <common/bk_include.h>
|
|
#include "diskio.h"
|
|
#include "test_fatfs.h"
|
|
#include <os/mem.h>
|
|
#include "ff.h"
|
|
|
|
#if (CONFIG_INT_WDT || CONFIG_TASK_WDT)
|
|
#include <driver/wdt.h>
|
|
#include <bk_wdt.h>
|
|
#endif
|
|
|
|
#define WR_RD_BUF_SIZE 1024
|
|
#define TEST_MP3_FILE_NAME "/Panama_Matteo.mp3"
|
|
#define TEST_TXT_FILE_NAME "/test1.txt"
|
|
#define TEST_DUMP_FILE_NAME "/dump1.txt"
|
|
#define TEST_TXT_FILE_NAME1 "/ÖÐÎÄÃû×Ö¿ÉÒÔÓж೤£¿Ïë¶à³¤¾Í¶à³¤£¬²»ÐÅÄãÒ§ÎÒ£¬ÐÅÎÒÇëÎÒ³Ô·¹.txt"
|
|
|
|
void bk_mem_dump_ex(const char *title, unsigned char *data, uint32_t data_len);
|
|
|
|
#if CONFIG_FATFS_SDCARD
|
|
FATFS *pfs = NULL;
|
|
|
|
FRESULT scan_files
|
|
(
|
|
char *path /* Start node to be scanned (***also used as work area***) */
|
|
)
|
|
{
|
|
FRESULT fr;
|
|
DIR dir;
|
|
FILINFO fno;
|
|
|
|
fr = f_opendir(&dir, path); /* Open the directory */
|
|
if (fr == FR_OK)
|
|
{
|
|
FATFS_LOGI("%s/\r\n", path);
|
|
while (1)
|
|
{
|
|
fr = f_readdir(&dir, &fno); /* Read a directory item */
|
|
if (fr != FR_OK)
|
|
{
|
|
break; /* Break on error */
|
|
}
|
|
if (fno.fname[0] == 0)
|
|
{
|
|
break; /* Break on end of dir */
|
|
}
|
|
if (fno.fattrib & AM_DIR)
|
|
{
|
|
/* It is a directory */
|
|
char *pathTemp = os_malloc(strlen(path)+strlen(fno.fname)+2);
|
|
if(pathTemp == 0)
|
|
{
|
|
FATFS_LOGE("%s:os_malloc dir fail \r\n", __func__);
|
|
break;
|
|
}
|
|
sprintf(pathTemp, "%s/%s", path, fno.fname);
|
|
fr = scan_files(pathTemp); /* Enter the directory */
|
|
if (fr != FR_OK)
|
|
{
|
|
os_free(pathTemp);
|
|
pathTemp = 0;
|
|
break;
|
|
}
|
|
if(pathTemp)
|
|
{
|
|
os_free(pathTemp);
|
|
pathTemp = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* It is a file. */
|
|
FATFS_LOGI("%s/%s\r\n", path, fno.fname);
|
|
}
|
|
}
|
|
f_closedir(&dir);
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_opendir failed:fr=%d\r\n", fr);
|
|
}
|
|
|
|
return fr;
|
|
}
|
|
|
|
void test_mount(DISK_NUMBER number)
|
|
{
|
|
FRESULT fr;
|
|
char cFileName[FF_MAX_LFN];
|
|
|
|
if (pfs != NULL)
|
|
{
|
|
os_free(pfs);
|
|
}
|
|
|
|
pfs = os_malloc(sizeof(FATFS));
|
|
if(NULL == pfs)
|
|
{
|
|
FATFS_LOGI("f_mount malloc failed!\r\n");
|
|
goto failed_mount;
|
|
}
|
|
|
|
sprintf(cFileName, "%d:", number);
|
|
fr = f_mount(pfs, cFileName, 1);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_mount failed:%d\r\n", fr);
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_mount OK!\r\n");
|
|
}
|
|
|
|
failed_mount:
|
|
FATFS_LOGI("----- test_mount %d over -----\r\n\r\n", number);
|
|
}
|
|
|
|
void test_unmount(DISK_NUMBER number)
|
|
{
|
|
FRESULT fr;
|
|
char cFileName[FF_MAX_LFN];
|
|
sprintf(cFileName, "%d:", number);
|
|
fr = f_unmount(number, cFileName, 1);
|
|
if (fr != FR_OK)
|
|
{
|
|
os_printf("f_unmount failed:%d\r\n", fr);
|
|
}
|
|
else
|
|
{
|
|
os_printf("f_unmount OK!\r\n");
|
|
}
|
|
os_printf("----- test_unmount %d over -----\r\n\r\n", number);
|
|
}
|
|
void test_getfree(DISK_NUMBER number)
|
|
{
|
|
FRESULT fr;
|
|
char cFileName[FF_MAX_LFN];
|
|
DWORD getnclst;
|
|
sprintf(cFileName, "%d:", number);
|
|
fr = f_getfree(cFileName, &getnclst, &pfs);
|
|
os_printf("test_getfree getnclst:DEC %d free space: %dMB\r\n", getnclst, getnclst/SD_CLUSTER_TO_MEM_64KB);
|
|
if (fr != FR_OK)
|
|
{
|
|
os_printf("f_getfree failed:%d\r\n", fr);
|
|
}
|
|
else
|
|
{
|
|
os_printf("f_getfree OK!\r\n");
|
|
}
|
|
os_printf("----- test_getfree %d over -----\r\n\r\n", number);
|
|
}
|
|
|
|
void scan_file_system(DISK_NUMBER number)
|
|
{
|
|
FRESULT fr;
|
|
char cFileName[FF_MAX_LFN];
|
|
|
|
FATFS_LOGI("\r\n----- scan_file_system %d start -----\r\n", number);
|
|
|
|
sprintf(cFileName, "%d:", number);
|
|
fr = scan_files(cFileName);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("scan_files failed!\r\n");
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("scan_files OK!\r\n");
|
|
}
|
|
|
|
FATFS_LOGI("----- scan_file_system %d over -----\r\n\r\n", number);
|
|
}
|
|
|
|
void test_fatfs(DISK_NUMBER number)
|
|
{
|
|
char cFileName[FF_MAX_LFN];
|
|
FIL file;
|
|
FRESULT fr;
|
|
|
|
FATFS_LOGI("\r\n----- test_fatfs %d start -----\r\n", number);
|
|
sprintf(cFileName, "%d:%s", number, TEST_MP3_FILE_NAME);
|
|
FATFS_LOGI("f_open \"%s\"\r\n", cFileName);
|
|
fr = f_open(&file, cFileName, FA_OPEN_EXISTING | FA_READ);
|
|
if (fr == FR_OK)
|
|
{
|
|
unsigned int uiTemp = 0;
|
|
unsigned int uiRdTotalLength = 0;
|
|
unsigned char ucRdTemp[WR_RD_BUF_SIZE];
|
|
|
|
do
|
|
{
|
|
FATFS_LOGI(".");
|
|
fr = f_read(&file, ucRdTemp, WR_RD_BUF_SIZE, &uiTemp);
|
|
if (fr == FR_OK)
|
|
{
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_read failed 1 fr = %d\r\n", fr);
|
|
goto error1;
|
|
}
|
|
uiRdTotalLength += uiTemp;
|
|
}
|
|
while (uiTemp == WR_RD_BUF_SIZE);
|
|
FATFS_LOGI("\r\n");
|
|
FATFS_LOGI("f_read: read total byte = %d\r\n", uiRdTotalLength);
|
|
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_close failed 1 fr = %d\r\n", fr);
|
|
goto error1;
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_close OK\r\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_open failed 1 fr = %d\r\n", fr);
|
|
goto error0;
|
|
}
|
|
|
|
FATFS_LOGI("----- test_fatfs %d over -----\r\n\r\n", number);
|
|
return;
|
|
|
|
error1:
|
|
f_close(&file);
|
|
error0:
|
|
FATFS_LOGI("----- test_fatfs %d failed -----\r\n\r\n", number);
|
|
}
|
|
|
|
|
|
void test_fatfs_read(DISK_NUMBER number, char *filename, uint64_t len)
|
|
{
|
|
char cFileName[FF_MAX_LFN];
|
|
FIL file;
|
|
FRESULT fr;
|
|
unsigned char *ucRdTemp = os_malloc(WR_RD_BUF_SIZE);
|
|
uint32_t packet_len = 0;
|
|
uint64_t left_len = 0;
|
|
|
|
if(ucRdTemp == 0)
|
|
{
|
|
FATFS_LOGI("%s:os_malloc fail \r\n", __func__);
|
|
goto error1;
|
|
}
|
|
|
|
FATFS_LOGI("\r\n----- test_fatfs %d start -----\r\n", number);
|
|
if(filename)
|
|
sprintf(cFileName, "%d:/%s", number, filename);
|
|
else
|
|
sprintf(cFileName, "%d:%s", number, TEST_TXT_FILE_NAME);
|
|
FATFS_LOGI("f_open \"%s\"\r\n", cFileName);
|
|
fr = f_open(&file, cFileName, FA_OPEN_EXISTING | FA_READ);
|
|
if (fr == FR_OK)
|
|
{
|
|
unsigned int uiTemp = 0;
|
|
unsigned int uiRdTotalLength = 0;
|
|
|
|
left_len = f_size(&file) < len? f_size(&file) : len;
|
|
FATFS_LOGI("will read left_len = %d \r\n", (uint32_t)left_len);
|
|
do
|
|
{
|
|
packet_len = left_len < WR_RD_BUF_SIZE? left_len : WR_RD_BUF_SIZE;
|
|
FATFS_LOGI("f_read start:%d bytes \r\n", packet_len);
|
|
fr = f_read(&file, ucRdTemp, packet_len, &uiTemp);
|
|
if (fr == FR_OK)
|
|
{
|
|
bk_mem_dump_ex("f_read one cycle", ucRdTemp, packet_len);
|
|
left_len -= uiTemp;
|
|
FATFS_LOGI("f_read one cycle finish:left_len = %d\r\n", (uint32_t)left_len);
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_read failed 1 fr = %d\r\n", fr);
|
|
goto error1;
|
|
}
|
|
uiRdTotalLength += uiTemp;
|
|
|
|
if(left_len == 0)
|
|
break;
|
|
}
|
|
while (uiTemp == packet_len);
|
|
|
|
FATFS_LOGI("f_read: read total byte = %d\r\n", uiRdTotalLength);
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_close failed 1 fr = %d\r\n", fr);
|
|
goto error1;
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_close OK\r\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_open failed 1 fr = %d\r\n", fr);
|
|
}
|
|
|
|
FATFS_LOGI("----- test_fatfs %d over -----\r\n\r\n", number);
|
|
if(ucRdTemp)
|
|
{
|
|
os_free(ucRdTemp);
|
|
ucRdTemp = 0;
|
|
}
|
|
|
|
return;
|
|
|
|
error1:
|
|
f_close(&file);
|
|
if(ucRdTemp)
|
|
{
|
|
os_free(ucRdTemp);
|
|
ucRdTemp = 0;
|
|
}
|
|
}
|
|
|
|
//File exist:append write contents(<64bytes).
|
|
//File not exist:create a file and write contents(<64bytes).
|
|
void test_fatfs_append_write(DISK_NUMBER number, char *filename, char *content, uint32_t len)
|
|
{
|
|
char cFileName[FF_MAX_LFN];
|
|
FIL file;
|
|
FRESULT fr;
|
|
|
|
FATFS_LOGI("\r\n----- test_fatfs %d start -----\r\n", number);
|
|
if(filename)
|
|
sprintf(cFileName, "%d:/%s", number, filename);
|
|
else
|
|
sprintf(cFileName, "%d:/%s", number, TEST_TXT_FILE_NAME);
|
|
FATFS_LOGI("f_open \"%s\"\r\n", cFileName);
|
|
|
|
fr = f_open(&file, cFileName, FA_OPEN_APPEND | FA_WRITE);
|
|
if (fr == FR_OK)
|
|
{
|
|
unsigned int uiTemp = 0;
|
|
unsigned int uiRdTotalLength = 0;
|
|
|
|
len = len > 64? 64:len;
|
|
do
|
|
{
|
|
FATFS_LOGI(".");
|
|
fr = f_write(&file, content, len, &uiTemp);
|
|
if (fr == FR_OK)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_write failed 1 fr = %d\r\n", fr);
|
|
goto error1;
|
|
}
|
|
uiRdTotalLength += uiTemp;
|
|
}
|
|
while (uiRdTotalLength != len);
|
|
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_close failed 1 fr = %d\r\n", fr);
|
|
goto error1;
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_close OK\r\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_open failed 1 fr = %d\r\n", fr);
|
|
}
|
|
|
|
FATFS_LOGI("----- test_fatfs %d over -----\r\n\r\n", number);
|
|
return;
|
|
|
|
error1:
|
|
f_close(&file);
|
|
}
|
|
|
|
#define TEST_FATFS_PACKET_LEN (1<<10)
|
|
void test_fatfs_dump(DISK_NUMBER number, char *filename, uint32_t start_addr, uint32_t dump_len)
|
|
{
|
|
FIL file;
|
|
FRESULT fr;
|
|
char cFileName[FF_MAX_LFN];
|
|
unsigned int uiTemp = 0;
|
|
|
|
FATFS_LOGI("\r\n----- %s %d start -----\r\n", __func__, number);
|
|
FATFS_LOGI("file_name=%s,start_addr=0x%0x,len=%d \r\n", filename, start_addr, dump_len);
|
|
|
|
if(filename)
|
|
sprintf(cFileName, "%d:/%s", number, filename);
|
|
else
|
|
sprintf(cFileName, "%d:%s", number, TEST_DUMP_FILE_NAME);
|
|
FATFS_LOGI("f_open start \"%s\"\r\n", cFileName);
|
|
|
|
fr = f_open(&file, cFileName, FA_OPEN_APPEND | FA_WRITE);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_open failed 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
FATFS_LOGI("f_write start\r\n");
|
|
//write:one time write all contents
|
|
do
|
|
{
|
|
fr = f_write(&file, (uint8_t *)start_addr, dump_len, &uiTemp);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_write fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
FATFS_LOGI("f_write end len = %d\r\n", uiTemp);
|
|
} while(0);
|
|
|
|
#if 1
|
|
//set file pointer to head
|
|
FATFS_LOGI("f_lseek start\r\n");
|
|
fr = f_lseek(&file, 0);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_lseek fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
#endif
|
|
FATFS_LOGI("f_close start\r\n");
|
|
//file close
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_close fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
return;
|
|
}
|
|
|
|
#define TEST_FATFS_MAX_FILE_LEN (1<<20)
|
|
#define TEST_FATFS_PACKET_LEN (1<<10)
|
|
void test_fatfs_auto_test(DISK_NUMBER number, char *filename, uint32_t len, uint32_t test_count, uint32_t start_addr)
|
|
{
|
|
uint32_t i = 0, j = 0, k = 0;
|
|
FIL file;
|
|
FRESULT fr;
|
|
char cFileName[FF_MAX_LFN];
|
|
uint8_t *content_p = (uint8_t *)start_addr;
|
|
unsigned int uiTemp = 0;
|
|
uint8_t *buf_p = 0;
|
|
uint32_t packet_cnt = 0, bytes_cnt = 0;
|
|
FATFS *checkspace_pfs = NULL;
|
|
DWORD freenclst;
|
|
|
|
FATFS_LOGD("\r\n----- %s %d start -----\r\n", __func__, number);
|
|
FATFS_LOGD("file_name=%s,len=%d,test_cnt=%d \r\n", filename, len, test_count);
|
|
|
|
if(filename)
|
|
sprintf(cFileName, "%d:/%s", number, filename);
|
|
else
|
|
sprintf(cFileName, "%d:%s", number, TEST_TXT_FILE_NAME);
|
|
FATFS_LOGD("f_open \"%s\"\r\n", cFileName);
|
|
|
|
len = len < TEST_FATFS_MAX_FILE_LEN? len : TEST_FATFS_MAX_FILE_LEN;
|
|
packet_cnt = len / TEST_FATFS_PACKET_LEN;
|
|
bytes_cnt = len % TEST_FATFS_PACKET_LEN;
|
|
|
|
buf_p = os_malloc(TEST_FATFS_PACKET_LEN);
|
|
if (buf_p == NULL)
|
|
{
|
|
FATFS_LOGE("malloc fail \r\n");
|
|
return;
|
|
}
|
|
|
|
for(i = 0; i < test_count; i++)
|
|
{
|
|
FATFS_LOGD("test round=%d start \r\n", i);
|
|
fr = f_getfree(cFileName, &freenclst, &checkspace_pfs);
|
|
if(fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_getfree failed 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
} else if(freenclst < SD_MIN_NUMBER_REMAINING_CLUSTERS) {
|
|
FATFS_LOGE("Insufficient Space! freenclst: %d free_mem:%d MB\r\n",freenclst, freenclst/SD_CLUSTER_TO_MEM_64KB);
|
|
goto exit;
|
|
}
|
|
|
|
fr = f_open(&file, cFileName, FA_OPEN_APPEND | FA_WRITE);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_open failed 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
//set file pointer to head
|
|
fr = f_lseek(&file, 0);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_lseek fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
//write:one time write all contents
|
|
do
|
|
{
|
|
fr = f_write(&file, (uint8_t *)content_p, len, &uiTemp);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_write fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
FATFS_LOGD("f_write len = %d\r\n", uiTemp);
|
|
}while(0);
|
|
|
|
//set file pointer to head
|
|
fr = f_lseek(&file, 0);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_lseek fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
//file close
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_close fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
FATFS_LOGD("check round=%d start \r\n", i);
|
|
fr = f_open(&file, cFileName, FA_OPEN_EXISTING | FA_READ);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_open failed 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
//set file pointer to head
|
|
fr = f_lseek(&file, 0);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_lseek fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
//read:as the buffer is not enough, so read each time less then TEST_FATFS_PACKET_LEN
|
|
for(j = 0; j < packet_cnt; j++)
|
|
{
|
|
fr = f_read(&file, (uint8_t *)buf_p, TEST_FATFS_PACKET_LEN, &uiTemp);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_read packet %d fail 1 fr = %d\r\n", j, fr);
|
|
goto exit;
|
|
}
|
|
FATFS_LOGD("f_read len = %d\r\n", uiTemp);
|
|
|
|
//compare
|
|
for(k = 0; k < TEST_FATFS_PACKET_LEN; k++)
|
|
{
|
|
if(*(content_p + j * TEST_FATFS_PACKET_LEN + k) != (*(buf_p + k)))
|
|
{
|
|
FATFS_LOGE("auto test fail packet[%d] byte[%d] err,source_val=0x%08x,tar_val=0x%08x \r\n", j, k, *(content_p + j * TEST_FATFS_PACKET_LEN + k), (*(buf_p + k)));
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
//left contents
|
|
if(bytes_cnt)
|
|
{
|
|
fr = f_read(&file, (uint8_t *)buf_p, bytes_cnt, &uiTemp);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_read last packet fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
FATFS_LOGD("f_read len = %d\r\n", uiTemp);
|
|
|
|
//compare
|
|
for(k = 0; k < bytes_cnt; k++)
|
|
{
|
|
if(*(content_p + packet_cnt * TEST_FATFS_PACKET_LEN + k) != (*(buf_p + k)))
|
|
{
|
|
FATFS_LOGE("auto test fail last packet byte[%d] err\r\n", k);
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
//set file pointer to head
|
|
fr = f_lseek(&file, 0);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_lseek fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
//file close
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_close fail 1 fr = %d\r\n", fr);
|
|
goto exit;
|
|
}
|
|
|
|
FATFS_LOGD("check round=%d end \r\n", i);
|
|
}
|
|
|
|
FATFS_LOGI("auto test succ \r\n");
|
|
|
|
exit:
|
|
os_free(buf_p);
|
|
buf_p = NULL;
|
|
}
|
|
|
|
void test_fatfs_format(DISK_NUMBER number)
|
|
{
|
|
FRESULT fr;
|
|
char cFileName[FF_MAX_LFN];
|
|
//unsigned char ucRdTemp[WR_RD_BUF_SIZE];
|
|
unsigned char *ucRdTemp = os_malloc(WR_RD_BUF_SIZE);
|
|
if(ucRdTemp == 0)
|
|
{
|
|
FATFS_LOGE("%s:os_malloc fail \r\n", __func__);
|
|
return;
|
|
}
|
|
|
|
FATFS_LOGD("----- test_fatfs_format %d start -----\r\n", number);
|
|
|
|
sprintf(cFileName, "%d:", number);
|
|
fr = f_mkfs(cFileName, FM_ANY, 65536, ucRdTemp, WR_RD_BUF_SIZE);
|
|
if (fr != FR_OK)
|
|
{
|
|
os_free(ucRdTemp);
|
|
FATFS_LOGE("f_mkfs fr=%d failed!\r\n", fr);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGI("f_mkfs OK!\r\n");
|
|
}
|
|
|
|
FATFS_LOGD("----- test_fatfs_format %d over -----\r\n", number);
|
|
|
|
if(ucRdTemp)
|
|
{
|
|
os_free(ucRdTemp);
|
|
ucRdTemp = 0;
|
|
}
|
|
}
|
|
|
|
#if 1
|
|
#define FATFS_TEST_CONCURRENCY_TASK_MAX_CNT (8)
|
|
static beken_thread_t s_fatfs_test_task_handle[FATFS_TEST_CONCURRENCY_TASK_MAX_CNT];
|
|
|
|
#define FATFS_TEST_CONCURRENCY_MEM_LEN (1024)
|
|
#define FATFS_TEST_CONCURRENCY_FILE_LEN (FATFS_TEST_CONCURRENCY_MEM_LEN * 128) //default:128k bytes
|
|
#define FATFS_TEST_CONCURRENCY_FILE_LEN_MAX (FATFS_TEST_CONCURRENCY_MEM_LEN * 1024 * 128) //MAX:128M bytes
|
|
|
|
static uint32_t *s_fatfs_test_src_p[FATFS_TEST_CONCURRENCY_TASK_MAX_CNT];
|
|
static uint32_t *s_fatfs_test_tar_p[FATFS_TEST_CONCURRENCY_TASK_MAX_CNT];
|
|
#define PSRAM_TEST_BYTES_LEN (8<<20)
|
|
//arg: ((DISK_NUMBER << 16) | task_id)
|
|
static void fatfs_test_concurrency_task(beken_thread_arg_t arg)
|
|
{
|
|
uint32_t task_id = ((uint32_t)arg & 0xffff)%FATFS_TEST_CONCURRENCY_TASK_MAX_CNT;
|
|
uint32_t path_id = ((uint32_t)arg >> 16) % DISK_NUMBER_COUNT;
|
|
char cFileName[FF_MAX_LFN];
|
|
FIL file;
|
|
FRESULT fr;
|
|
uint64_t left_len = 0;
|
|
unsigned int uiTemp = 0;
|
|
uint32_t i;
|
|
|
|
FATFS_LOGI("path_id=%d,taskid=%d\r\n", path_id, task_id);
|
|
sprintf(cFileName, "%u:/fatfs_test_task_%u.txt", path_id, task_id);
|
|
while (1) {
|
|
//init mem value
|
|
for(i = 0; i < FATFS_TEST_CONCURRENCY_MEM_LEN/4; i++)
|
|
*(s_fatfs_test_src_p[task_id] + i) = (uint32_t)(s_fatfs_test_src_p[task_id] + i);
|
|
|
|
//open file
|
|
FATFS_LOGI("f_open \"%s\"\r\n", cFileName);
|
|
fr = f_open(&file, cFileName, FA_OPEN_APPEND | FA_WRITE);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_open failed fr = %d\r\n", fr);
|
|
continue;
|
|
}
|
|
|
|
//write to SDCARD
|
|
left_len = FATFS_TEST_CONCURRENCY_FILE_LEN;
|
|
do
|
|
{
|
|
fr = f_write(&file, s_fatfs_test_src_p[task_id], FATFS_TEST_CONCURRENCY_MEM_LEN, &uiTemp);
|
|
if ((fr == FR_OK) /*&& (uiTemp == FATFS_TEST_CONCURRENCY_MEM_LEN)*/)
|
|
{
|
|
left_len -= FATFS_TEST_CONCURRENCY_MEM_LEN;
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGE("f_write failed fr = %d,uiTemp=%d,left_len=%d\r\n", fr, uiTemp, left_len);
|
|
continue;
|
|
}
|
|
}
|
|
while (left_len);
|
|
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_close fail 1 fr = %d\r\n", fr);
|
|
continue;
|
|
}
|
|
|
|
#if CONFIG_WDT
|
|
bk_wdt_feed();
|
|
#if CONFIG_TASK_WDT
|
|
bk_task_wdt_feed();
|
|
#endif
|
|
#endif
|
|
|
|
//read from SDCARD and compare
|
|
FATFS_LOGI("f_open \"%s\"\r\n", cFileName);
|
|
fr = f_open(&file, cFileName, FA_OPEN_EXISTING | FA_READ);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGE("f_open failed fr = %d\r\n", fr);
|
|
continue;
|
|
}
|
|
|
|
left_len = FATFS_TEST_CONCURRENCY_FILE_LEN;
|
|
do
|
|
{
|
|
fr = f_read(&file, s_fatfs_test_tar_p[task_id], FATFS_TEST_CONCURRENCY_MEM_LEN, &uiTemp);
|
|
if (fr == FR_OK)
|
|
{
|
|
left_len -= FATFS_TEST_CONCURRENCY_MEM_LEN;
|
|
}
|
|
else
|
|
{
|
|
FATFS_LOGE("f_read failed fr = %d,uiTemp=%d,left_len=%d\r\n", fr, uiTemp, left_len);
|
|
continue;
|
|
}
|
|
|
|
//compare
|
|
for(uint32_t i = 0; i < FATFS_TEST_CONCURRENCY_MEM_LEN/4; i++)
|
|
{
|
|
if(*(s_fatfs_test_src_p[task_id] + i) != *(s_fatfs_test_tar_p[task_id] + i))
|
|
{
|
|
FATFS_LOGE("compare failed src = 0x%x,tar=0x%x,i=%d\r\n", *(s_fatfs_test_src_p[task_id] + i), *(s_fatfs_test_tar_p[task_id] + i), i);
|
|
}
|
|
}
|
|
}
|
|
while (left_len);
|
|
|
|
fr = f_close(&file);
|
|
if (fr != FR_OK)
|
|
{
|
|
FATFS_LOGI("f_close failed 1 fr = %d\r\n", fr);
|
|
continue;
|
|
}
|
|
|
|
#if CONFIG_WDT
|
|
bk_wdt_feed();
|
|
#if CONFIG_TASK_WDT
|
|
bk_task_wdt_feed();
|
|
#endif
|
|
#endif
|
|
|
|
rtos_delay_milliseconds(20);
|
|
}
|
|
|
|
s_fatfs_test_task_handle[task_id] = NULL;
|
|
rtos_delete_thread(NULL);
|
|
|
|
if(s_fatfs_test_src_p[task_id])
|
|
{
|
|
os_free(s_fatfs_test_src_p[task_id]);
|
|
s_fatfs_test_src_p[task_id] = NULL;
|
|
}
|
|
|
|
if(s_fatfs_test_tar_p[task_id])
|
|
{
|
|
os_free(s_fatfs_test_tar_p[task_id]);
|
|
s_fatfs_test_tar_p[task_id] = NULL;
|
|
}
|
|
}
|
|
|
|
void test_fatfs_concurrency(DISK_NUMBER number, uint32_t task_count, uint32_t file_size)
|
|
{
|
|
bk_err_t ret = BK_OK;
|
|
if(task_count > FATFS_TEST_CONCURRENCY_TASK_MAX_CNT)
|
|
task_count = FATFS_TEST_CONCURRENCY_TASK_MAX_CNT; //max is 8
|
|
|
|
for(uint32_t i = 0; i < task_count; i++)
|
|
{
|
|
if (!s_fatfs_test_task_handle[i])
|
|
{
|
|
ret = rtos_create_thread(&s_fatfs_test_task_handle[i],
|
|
4,
|
|
"fatfs_test",
|
|
(beken_thread_function_t)fatfs_test_concurrency_task,
|
|
4 * 1024,
|
|
(beken_thread_arg_t)((number << 16) | i)); //arg: ((DISK_NUMBER << 16) | task_id)
|
|
if (ret != BK_OK)
|
|
{
|
|
s_fatfs_test_task_handle[i] = NULL;
|
|
FATFS_LOGE("Failed to create fatfs test task: %d\r\n", ret);
|
|
return;
|
|
}
|
|
|
|
if(s_fatfs_test_src_p[i] == NULL)
|
|
s_fatfs_test_src_p[i] = (uint32_t *)os_malloc(FATFS_TEST_CONCURRENCY_MEM_LEN);
|
|
BK_ASSERT(s_fatfs_test_src_p[i]);
|
|
|
|
if(s_fatfs_test_tar_p[i] == NULL)
|
|
s_fatfs_test_tar_p[i] = (uint32_t *)os_malloc(FATFS_TEST_CONCURRENCY_MEM_LEN);
|
|
BK_ASSERT(s_fatfs_test_tar_p[i]);
|
|
|
|
FATFS_LOGI("s_fatfs_test_src_p[%d]=0x%x,tar=0x%x\r\n", i, s_fatfs_test_src_p[i], s_fatfs_test_tar_p[i]);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
// eof
|
|
|