328 lines
7.9 KiB
C
Executable File
328 lines
7.9 KiB
C
Executable File
/**************************************************************************
|
|
*
|
|
* Copyright (c) 2009-2018 by SiFar Technology, Inc.
|
|
*
|
|
* This software is copyrighted by and is the property of SiFar
|
|
* Technology, Inc.. All rights are reserved by SiFar Technology, Inc..
|
|
* This software may only be used in accordance with the corresponding
|
|
* license agreement. Any unauthorized use, duplication, distribution,
|
|
* or disclosure of this software is expressly forbidden.
|
|
*
|
|
* This Copyright notice MUST not be removed or modified without prior
|
|
* written consent of SiFar Technology, Inc..
|
|
*
|
|
* SiFar Technology, Inc. reserves the right to modify this software without notice.
|
|
*
|
|
* Author: Payton
|
|
* Ver: 1.0.0 2023.02.14
|
|
* Description: sd code
|
|
*
|
|
**************************************************************************/
|
|
|
|
|
|
//#include <linux/module.h>
|
|
#include <sf_mcu.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
//#include <linux/input.h>
|
|
|
|
#include <sys/fcntl.h>
|
|
#include <sys/stat.h>
|
|
//#include <sys/ioctl.h>
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <kwrap/util.h>
|
|
#include <sys/wait.h>
|
|
#include <errno.h>
|
|
#include <kwrap/debug.h>
|
|
#include <time.h>
|
|
//#include <io/gpio.h>
|
|
#include "UIInfo/UIInfo.h"
|
|
#include <FileSysTsk.h>
|
|
#include "sf_sd_common.h"
|
|
|
|
static BOOL IsCardFull = FALSE;
|
|
SF_CALLBACK_SD_CMD g_fpSd_Exist_CB = NULL;
|
|
extern BOOL DrvCARD_DetStrgCard(void);
|
|
static BOOL IsEmmcFull = FALSE;
|
|
|
|
SF_RTOS_ST_MMC_DEV *sf_rtos_mmc_dev[MMC_DEV_MAX_NUM] = {NULL};
|
|
|
|
BOOL sf_is_card_full(void)
|
|
{
|
|
//printf("[%s]:%d IsCardFull:%d\n", __FUNCTION__, __LINE__, IsCardFull);
|
|
return IsCardFull;
|
|
}
|
|
|
|
UINT32 sf_check_card_full(void)
|
|
{
|
|
UINT64 diskFree = 0;
|
|
UINT32 ret = 0;
|
|
|
|
//UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(!sf_in_card_exist())
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/*check disk free size*/
|
|
diskFree = FileSys_GetDiskInfo(FST_INFO_FREE_SPACE);
|
|
diskFree = diskFree/1024/1024;
|
|
|
|
if(diskFree < 30) /* 30MB */
|
|
{
|
|
ret = TRUE;
|
|
//if(0 == puiPara->SdLoopSwitch)
|
|
{
|
|
IsCardFull = TRUE;
|
|
}
|
|
//printf("%s:%d sd card is full diskFree=%lu",__FUNCTION__,__LINE__,diskFree);
|
|
}
|
|
else
|
|
{
|
|
ret = FALSE;
|
|
//printf("%s:%d sd card no full diskFree=%lu",__FUNCTION__,__LINE__,diskFree);
|
|
}
|
|
|
|
printf("[%s:%d]sd card diskFree=%lluM\n", __FUNCTION__, __LINE__, diskFree);
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL sf_is_emmc_full(void)
|
|
{
|
|
//printf("[%s]:%d IsCardFull:%d\n", __FUNCTION__, __LINE__, IsCardFull);
|
|
return IsEmmcFull;
|
|
}
|
|
|
|
UINT32 sf_check_emmc_full(void)
|
|
{
|
|
UINT64 diskFree = 0;
|
|
UINT32 ret = 0;
|
|
|
|
/*check disk free size*/
|
|
diskFree = FileSys_GetDiskInfoEx('B', FST_INFO_FREE_SPACE);
|
|
diskFree = diskFree/1024/1024;
|
|
|
|
if(diskFree < 30) /* 30MB */
|
|
{
|
|
ret = TRUE;
|
|
//if(0 == puiPara->SdLoopSwitch)
|
|
{
|
|
IsCardFull = TRUE;
|
|
}
|
|
//printf("%s:%d sd card is full diskFree=%lu",__FUNCTION__,__LINE__,diskFree);
|
|
}
|
|
else
|
|
{
|
|
ret = FALSE;
|
|
//printf("%s:%d sd card no full diskFree=%lu",__FUNCTION__,__LINE__,diskFree);
|
|
}
|
|
|
|
printf("[%s:%d]emmc diskFree=%lluM\n", __FUNCTION__, __LINE__, diskFree);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void sf_sd_exist_reg_cb(SF_CALLBACK_SD_CMD fpCB)
|
|
{
|
|
g_fpSd_Exist_CB = fpCB;
|
|
}
|
|
|
|
BOOL sf_in_card_exist(void)
|
|
{
|
|
return DrvCARD_DetStrgCard();
|
|
/*
|
|
if(g_fpSd_Exist_CB)
|
|
{
|
|
return g_fpSd_Exist_CB();
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}*/
|
|
|
|
}
|
|
|
|
void SF_RtosStrgInit(void)
|
|
{
|
|
for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
|
|
{
|
|
sf_rtos_mmc_dev[i] = (SF_RTOS_ST_MMC_DEV *)malloc(sizeof(SF_RTOS_ST_MMC_DEV));
|
|
if(sf_rtos_mmc_dev[i] == NULL) {
|
|
// 处理内存分配失败的情况
|
|
}
|
|
sf_rtos_mmc_dev[i]->dcf_handle = -1;
|
|
sf_rtos_mmc_dev[i]->dev_type = MMC_DEV_EMMC;
|
|
//sf_rtos_mmc_dev[i]->node = MMC_DEV_NODE_STATE_NO;
|
|
sf_rtos_mmc_dev[i]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
|
|
sf_rtos_mmc_dev[i]->space_state = MMC_DEV_SPACE_STATE_ENOUGH;
|
|
//sf_rtos_mmc_dev[i]->loop_state = MMC_DEV_LOOP_STATE_NO;
|
|
}
|
|
DBG_WRN("SF_RtosStrgInit!\n");
|
|
}
|
|
|
|
void SF_RtosStrgUnInit(void)
|
|
{
|
|
for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
|
|
{
|
|
if(sf_rtos_mmc_dev[i] != NULL) {
|
|
free(sf_rtos_mmc_dev[i]);
|
|
sf_rtos_mmc_dev[i] = NULL;
|
|
}
|
|
}
|
|
DBG_WRN("SF_RtosStrgUnInit!\n");
|
|
}
|
|
|
|
static UINT32 sf_rtos_mmc_dev_space_check_full(MMC_DEV_TYPE mmc_dev)
|
|
{
|
|
UINT64 diskFree = 0;
|
|
UINT32 ret = 0;
|
|
|
|
//UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(!sf_in_card_exist())
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/*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 */
|
|
{
|
|
IsCardFull = TRUE;
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
IsCardFull = FALSE;
|
|
ret = 0;
|
|
}
|
|
DBG_WRN("[strg_id:%d]diskFree=%lluM, ret = %d\n", mmc_dev, diskFree, ret);
|
|
return ret;
|
|
}
|
|
|
|
int SF_RtosStrgRegister(int devid, int mounted_state)
|
|
{
|
|
UIMenuStoreInfo *puiPara = sf_ui_para_get();
|
|
if(mounted_state == FST_STA_OK)
|
|
{
|
|
sf_rtos_mmc_dev[devid]->moumted_state = MMC_DEV_MOUNT_STATE_MOUNTED;
|
|
}
|
|
else
|
|
{
|
|
sf_rtos_mmc_dev[devid]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
|
|
}
|
|
|
|
if(puiPara->SdLoopSwitch == 1)
|
|
{
|
|
sf_rtos_mmc_dev[devid]->loop_state = MMC_DEV_LOOP_STATE_ON;
|
|
}
|
|
else
|
|
sf_rtos_mmc_dev[devid]->loop_state = MMC_DEV_LOOP_STATE_OFF;
|
|
|
|
DBG_WRN("devid = %d, state = %d\n", devid, mounted_state);
|
|
return 0;
|
|
}
|
|
|
|
void SF_RtosStrgSetDcfHandle(UINT32 strg_id, UINT32 handle)
|
|
{
|
|
sf_rtos_mmc_dev[strg_id]->dcf_handle = handle;
|
|
DBG_WRN("strg_id = %d, handle = %d\n", strg_id, handle);
|
|
}
|
|
|
|
|
|
SF_RTOS_ST_MMC_DEV *SF_RtosStrgCheckWorkableDev(void)
|
|
{
|
|
MMC_DEV_TYPE workable_dev = MMC_DEV_NO;
|
|
|
|
if((sf_rtos_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED) &&
|
|
(sf_rtos_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED))
|
|
{
|
|
workable_dev = MMC_DEV_NO;
|
|
}
|
|
else if(sf_rtos_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
|
|
{
|
|
if(!sf_rtos_mmc_dev_space_check_full(MMC_DEV_EMMC))
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
else
|
|
{
|
|
if(sf_rtos_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
}
|
|
}
|
|
else if(sf_rtos_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
|
|
{
|
|
if(!sf_rtos_mmc_dev_space_check_full(MMC_DEV_SD))
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
else
|
|
{
|
|
if(sf_rtos_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!sf_rtos_mmc_dev_space_check_full(MMC_DEV_EMMC) &&
|
|
!sf_rtos_mmc_dev_space_check_full(MMC_DEV_SD))
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
else if(!sf_rtos_mmc_dev_space_check_full(MMC_DEV_EMMC))
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
else if(!sf_rtos_mmc_dev_space_check_full(MMC_DEV_SD))
|
|
{
|
|
workable_dev = MMC_DEV_SD;
|
|
}
|
|
else
|
|
{
|
|
if(sf_rtos_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
|
|
{
|
|
workable_dev = MMC_DEV_EMMC;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
DBG_WRN("dev_id = %d!!!\n", workable_dev);
|
|
for(int i = 0; i < 2; i++)
|
|
{
|
|
sf_rtos_mmc_dev[i]->dev_type = workable_dev;
|
|
DBG_WRN("mount:%d\n", sf_rtos_mmc_dev[i]->moumted_state);
|
|
}
|
|
if(workable_dev == MMC_DEV_NO)
|
|
{
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
return sf_rtos_mmc_dev[workable_dev];
|
|
}
|
|
|
|
}
|
|
|
|
|