347 lines
8.1 KiB
C
Executable File
347 lines
8.1 KiB
C
Executable File
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/vfs.h>
|
|
#include <sys/ioctl.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
#include <dirent.h>
|
|
#include <memory.h>
|
|
#include "DCF.h"
|
|
#include "sf_type.h"
|
|
#include "sf_log.h"
|
|
|
|
#include "SF_SysStrgMng.h"
|
|
#include <sf_param_common.h>
|
|
#include <sf_param_struct.h>
|
|
#include <FileSysTsk.h>
|
|
|
|
typedef struct
|
|
{
|
|
int event;
|
|
int dev_id;
|
|
int mounted_status;
|
|
}STRG_CB_PARAM;
|
|
|
|
|
|
SF_THREAD_S MMCMonitorTskCfg =
|
|
{
|
|
.IsRun = 0,
|
|
.TskId = -1,
|
|
};
|
|
|
|
|
|
SF_ST_MMC_DEV *sf_mmc_dev[MMC_DEV_MAX_NUM] = {NULL};
|
|
|
|
SF_ST_MMC_DEV *pMMCDev = NULL;
|
|
|
|
void SF_SetMMCDev(SF_ST_MMC_DEV *pDev)
|
|
{
|
|
pMMCDev = pDev;
|
|
}
|
|
|
|
SF_ST_MMC_DEV *SF_GetMMCDev(void)
|
|
{
|
|
return pMMCDev;
|
|
}
|
|
|
|
void SF_StrgInit(void)
|
|
{
|
|
for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
|
|
{
|
|
sf_mmc_dev[i] = (SF_ST_MMC_DEV *)malloc(sizeof(SF_ST_MMC_DEV));
|
|
if(sf_mmc_dev[i] == NULL) {
|
|
MLOGD("SF_StrgInit Failed, id = %d\n", i);
|
|
}
|
|
sf_mmc_dev[i]->dcf_handle = -1;
|
|
sf_mmc_dev[i]->dev_type = MMC_DEV_NO;
|
|
sf_mmc_dev[i]->node = MMC_DEV_NODE_STATE_NO_EXIST;
|
|
sf_mmc_dev[i]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
|
|
sf_mmc_dev[i]->space_state = MMC_DEV_SPACE_STATE_ENOUGH;
|
|
sf_mmc_dev[i]->loop_state = MMC_DEV_LOOP_STATE_OFF;
|
|
}
|
|
}
|
|
|
|
void SF_StrgUnInit(void)
|
|
{
|
|
for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
|
|
{
|
|
if(sf_mmc_dev[i] != NULL) {
|
|
free(sf_mmc_dev[i]);
|
|
sf_mmc_dev[i] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SF_StrgSetDcfHandle(UINT32 strg_id, UINT32 handle)
|
|
{
|
|
sf_mmc_dev[strg_id]->dcf_handle = handle;
|
|
}
|
|
|
|
static UINT32 SF_StrgSpaceCheckFull(MMC_DEV_TYPE mmc_dev)
|
|
{
|
|
UINT64 diskFree = 0;
|
|
UINT32 ret = 0;
|
|
|
|
return 0;
|
|
/*check disk free size*/
|
|
if(mmc_dev == MMC_DEV_SD)
|
|
{
|
|
diskFree = FileSys_GetDiskInfoEx('A', FST_INFO_FREE_SPACE);
|
|
}
|
|
else
|
|
{
|
|
diskFree = FileSys_GetDiskInfoEx('B', FST_INFO_FREE_SPACE);
|
|
}
|
|
|
|
diskFree = diskFree/1024/1024;
|
|
|
|
if(diskFree < 30) /* 30MB */
|
|
{
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
ret = 0;
|
|
}
|
|
//MLOGD("[%s:%d]sd card diskFree=%lluM\n", __FUNCTION__, __LINE__, diskFree);
|
|
return ret;
|
|
}
|
|
|
|
static int SF_StrgNodeCheck(const char *devName)
|
|
{
|
|
int tryCnt = 200;
|
|
int ret = access(devName, F_OK);
|
|
while (ret != 0 && tryCnt--)
|
|
{
|
|
usleep(10*1000);
|
|
ret = access(devName, F_OK);
|
|
}
|
|
|
|
if (tryCnt < 0)
|
|
{
|
|
printf("no found %s\n", devName);
|
|
return -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void SF_StrgRegister(SF_MESSAGE_BUF_S *pMessageBuf)
|
|
{
|
|
MLOGD("[dev_id:%d, evt:%d]\n",pMessageBuf->arg2, pMessageBuf->arg1);
|
|
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
|
|
if(pMessageBuf->arg2 == MMC_DEV_SD)
|
|
{
|
|
if(pMessageBuf->arg1 == CMD_SD_STRG_CB_INSERTED)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_SD]->node = MMC_DEV_NODE_STATE_EXIST;
|
|
}
|
|
else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_REMOVED)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_SD]->node = MMC_DEV_NODE_STATE_NO_EXIST;
|
|
}
|
|
else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_MOUNT_FINISH)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_SD]->moumted_state = MMC_DEV_MOUNT_STATE_MOUNTED;
|
|
}
|
|
else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_UNMOUNT_FINISH)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_SD]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
|
|
}
|
|
|
|
if(puiPara->SdLoopSwitch == 1)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_SD]->loop_state = MMC_DEV_LOOP_STATE_ON;
|
|
}
|
|
else if(puiPara->SdLoopSwitch == 0)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_SD]->loop_state = MMC_DEV_LOOP_STATE_OFF;
|
|
}
|
|
|
|
}
|
|
else if(pMessageBuf->arg2 == MMC_DEV_EMMC)
|
|
{
|
|
if(SF_StrgNodeCheck(EMMC_DEVICE_NAME) == 0)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_EMMC]->node = MMC_DEV_NODE_STATE_EXIST;
|
|
}
|
|
else
|
|
{
|
|
sf_mmc_dev[MMC_DEV_EMMC]->node = MMC_DEV_NODE_STATE_NO_EXIST;
|
|
}
|
|
|
|
if(pMessageBuf->arg1 == CMD_SD_STRG_CB_MOUNT_FINISH)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_EMMC]->moumted_state = MMC_DEV_MOUNT_STATE_MOUNTED;
|
|
}
|
|
else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_UNMOUNT_FINISH)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_EMMC]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
|
|
}
|
|
|
|
if(puiPara->SdLoopSwitch == 1)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_EMMC]->loop_state = MMC_DEV_LOOP_STATE_ON;
|
|
}
|
|
else if(puiPara->SdLoopSwitch == 0)
|
|
{
|
|
sf_mmc_dev[MMC_DEV_EMMC]->loop_state = MMC_DEV_LOOP_STATE_OFF;
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < 2; i++)
|
|
{
|
|
MLOGD("node:%d, mount:%d, loop:%d\n",
|
|
sf_mmc_dev[i]->node, sf_mmc_dev[i]->moumted_state,
|
|
sf_mmc_dev[i]->loop_state);
|
|
}
|
|
}
|
|
|
|
SF_ST_MMC_DEV *SF_StrgCheckWorkableDev(void)
|
|
{
|
|
MMC_DEV_TYPE workable_dev = MMC_DEV_NO;
|
|
//MLOGD("sf mmc check workable dev start!!!\n");
|
|
|
|
if((sf_mmc_dev[MMC_DEV_SD]->node == MMC_DEV_NODE_STATE_NO_EXIST) &&
|
|
(sf_mmc_dev[MMC_DEV_EMMC]->node == MMC_DEV_NODE_STATE_NO_EXIST))
|
|
{
|
|
workable_dev = MMC_DEV_NO;
|
|
}
|
|
else if(sf_mmc_dev[MMC_DEV_EMMC]->node == MMC_DEV_NODE_STATE_NO_EXIST) //EMMC节点不存在
|
|
{
|
|
if(sf_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_MOUNTED)
|
|
{
|
|
if(!SF_StrgSpaceCheckFull(MMC_DEV_SD))
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
else
|
|
{
|
|
if(sf_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(sf_mmc_dev[MMC_DEV_SD]->node == MMC_DEV_NODE_STATE_NO_EXIST) //SD节点不存在
|
|
{
|
|
if(sf_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_MOUNTED)
|
|
{
|
|
if(!SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
else
|
|
{
|
|
if(sf_mmc_dev[MMC_DEV_EMMC]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else //MMC节点都存在
|
|
{
|
|
if((sf_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED) &&
|
|
(sf_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED))
|
|
{
|
|
workable_dev = MMC_DEV_NO;
|
|
}
|
|
else if(sf_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
|
|
{
|
|
if(!SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
else
|
|
{
|
|
if(sf_mmc_dev[MMC_DEV_EMMC]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
}
|
|
}
|
|
else if(sf_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
|
|
{
|
|
if(!SF_StrgSpaceCheckFull(MMC_DEV_SD))
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
else
|
|
{
|
|
if(sf_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!SF_StrgSpaceCheckFull(MMC_DEV_SD) &&
|
|
!SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
else if(!SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
else if(!SF_StrgSpaceCheckFull(MMC_DEV_SD))
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
else
|
|
{
|
|
if(sf_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < 2; i++)
|
|
{
|
|
sf_mmc_dev[i]->dev_type = workable_dev;
|
|
}
|
|
|
|
if(workable_dev == MMC_DEV_NO)
|
|
{
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
return sf_mmc_dev[workable_dev];
|
|
}
|
|
}
|
|
|
|
static void* mmc_monitoring_thread(void *arg)
|
|
{
|
|
while(MMCMonitorTskCfg.IsRun)
|
|
{
|
|
#if USE_MMC_DEV_CHECK
|
|
SF_SetMMCDev(SF_StrgCheckWorkableDev());
|
|
#endif
|
|
sf_sleep_ms(500);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int sf_mmc_dev_check_start(void)
|
|
{
|
|
int ret = pthread_create(&MMCMonitorTskCfg.TskId, NULL, mmc_monitoring_thread, NULL);
|
|
if(ret != SF_SUCCESS)
|
|
{
|
|
MLOGD("thread sf_mmc_monitoring_start creat fail!\n");
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|