diff --git a/code/application/source/cardv/Makefile b/code/application/source/cardv/Makefile index b7ad8541b..9c39f8166 100755 --- a/code/application/source/cardv/Makefile +++ b/code/application/source/cardv/Makefile @@ -118,6 +118,7 @@ SRC = \ ./SrcCode/System/SysAudio_Exe.c \ ./SrcCode/System/SysStrg_CB.c \ ./SrcCode/System/SysStrg_Exe.c \ + ./SrcCode/System/SF_SysStrgMng.c \ ./SrcCode/System/SysSensor_Exe.c \ ./SrcCode/System/SysFW_Upgrade_Strg_Obj.c \ ./SrcCode/System/SysFW_Upgrade.c \ diff --git a/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrg.c b/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrg.c index 4394af02d..54f0f1145 100755 --- a/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrg.c +++ b/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrg.c @@ -178,4 +178,4 @@ void GxStrg_SetStrgMountStatus(UINT32 DevID, BOOL bMountOK) } else { g_LnxStrgStatus[DevID].IsFormatted = FALSE; } -} \ No newline at end of file +} diff --git a/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrgLnx.c b/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrgLnx.c index 5c7fff495..de4a77cb2 100644 --- a/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrgLnx.c +++ b/code/application/source/cardv/SrcCode/Gx/GxStrg/GxStrgLnx.c @@ -346,4 +346,4 @@ INT32 GxStrgLnx_Det(UINT32 DevId) } else { return DET_CARD_REMOVED; } -} \ No newline at end of file +} diff --git a/code/application/source/cardv/SrcCode/PrjCfg_DVCam.h b/code/application/source/cardv/SrcCode/PrjCfg_DVCam.h index de92a323f..15b1eb972 100755 --- a/code/application/source/cardv/SrcCode/PrjCfg_DVCam.h +++ b/code/application/source/cardv/SrcCode/PrjCfg_DVCam.h @@ -830,7 +830,7 @@ // 2. enable FS_DX_TYPE_DRIVE_B as DX_TYPE_CARD2 // 3. enable FS_MULTI_STRG_FUNC // 4. NETWORK = NETWORK_NONE (Both uITRON and eCos) -#define FS_MULTI_STRG_FUNC DISABLE +#define FS_MULTI_STRG_FUNC ENABLE //MULTI_DRIVE #if defined(_EMBMEM_EMMC_) && (FS_MULTI_STRG_FUNC==DISABLE) #define FS_DX_TYPE_DRIVE_A USER_DX_TYPE_EMBMEM_FAT diff --git a/code/application/source/cardv/SrcCode/System/SF_SysStrgMng.c b/code/application/source/cardv/SrcCode/System/SF_SysStrgMng.c new file mode 100755 index 000000000..208aee78c --- /dev/null +++ b/code/application/source/cardv/SrcCode/System/SF_SysStrgMng.c @@ -0,0 +1,326 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "DCF.h" +#include "sf_type.h" +#include "sf_log.h" + +#include "SF_SysStrgMng.h" +#include +#include +#include + +typedef struct +{ + int event; + int dev_id; + int mounted_status; +}STRG_CB_PARAM; + +SF_ST_MMC_DEV *sf_mmc_dev[MMC_DEV_MAX_NUM] = {NULL}; + +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) { + // 处理内存分配失败的情况 + } + 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; + sf_mmc_dev[i]->moumted_state = MMC_DEV_MOUNT_STATE_NO; + sf_mmc_dev[i]->space_state = MMC_DEV_SPACE_STATE_NO; + sf_mmc_dev[i]->loop_state = MMC_DEV_LOOP_STATE_NO; + } +} + +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; + + /*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, space:%d, loop:%d\n", + sf_mmc_dev[i]->node, sf_mmc_dev[i]->moumted_state, + sf_mmc_dev[i]->space_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"); + + UINT32 isfull = 0; + isfull = SF_StrgSpaceCheckFull(MMC_DEV_EMMC); + if(isfull == 1) + { + sf_mmc_dev[MMC_DEV_EMMC]->space_state = MMC_DEV_SPACE_STATE_NO_ENOUGH; + } + else if(isfull == 0) + { + sf_mmc_dev[MMC_DEV_EMMC]->space_state = MMC_DEV_SPACE_STATE_ENOUGH; + } + + isfull = SF_StrgSpaceCheckFull(MMC_DEV_SD); + if(isfull == 1) + { + sf_mmc_dev[MMC_DEV_SD]->space_state = MMC_DEV_SPACE_STATE_NO_ENOUGH; + } + else if(isfull == 0) + { + sf_mmc_dev[MMC_DEV_SD]->space_state = MMC_DEV_SPACE_STATE_ENOUGH; + } + + 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_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + workable_dev = MMC_DEV_SD; + } + else if(sf_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_NO_ENOUGH) + { + 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_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + workable_dev = MMC_DEV_EMMC; + } + else if(sf_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_NO_ENOUGH) + { + 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_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + 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_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + 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_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH && + sf_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + workable_dev = MMC_DEV_EMMC; + } + else if(sf_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + workable_dev = MMC_DEV_EMMC; + } + else if(sf_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + 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; + } + } + } + } + + //MLOGD("sf mmc check workable dev end, dev_id = %d!!!\n", workable_dev); + for(int i = 0; i < 2; i++) + { + sf_mmc_dev[i]->dev_type = workable_dev; + //MLOGD("node:%d, mount:%d, space:%d, loop:%d\n", + //sf_mmc_dev[i]->node, sf_mmc_dev[i]->moumted_state, + //sf_mmc_dev[i]->space_state, sf_mmc_dev[i]->loop_state); + } + + if(workable_dev == MMC_DEV_NO) + { + return NULL; + } + else + { + return sf_mmc_dev[workable_dev]; + } +} diff --git a/code/application/source/cardv/SrcCode/System/SF_SysStrgMng.h b/code/application/source/cardv/SrcCode/System/SF_SysStrgMng.h new file mode 100755 index 000000000..cf5f67873 --- /dev/null +++ b/code/application/source/cardv/SrcCode/System/SF_SysStrgMng.h @@ -0,0 +1,91 @@ +/************************************************************************** + * + * Copyright (c) 2015-2021 by WuYuan 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.. + * + * WuYuan Technology, Inc. reserves the right to modify this software without notice. + * + * Author: Sober + * Ver: 1.0.0 2023.12.23 + * Description: Creat +**************************************************************************/ +#ifndef _SF_SYS_STRG_MNG_H_ +#define _SF_SYS_STRG_MNG_H_ +#include "sf_type.h" +#include "sf_param_common.h" + +#define MMC_DEV_MAX_NUM (2) + +#define SD_NODES_NAME "/dev/mmcblk0" +#define SD_DEVICE_NAME "/dev/mmcblk0p1" +#define SD_MOUNT_ROOT "/mnt/sd" + +#define EMMC_NODES_NAME "/dev/mmcblk1" +#define EMMC_DEVICE_NAME "/dev/mmcblk1p1" +#define EMMC_MOUNT_ROOT "/mnt/sd2" + + +typedef enum +{ + MMC_DEV_SD = 0, + MMC_DEV_EMMC = 1, + MMC_DEV_NO = 2, +}MMC_DEV_TYPE; + +typedef enum +{ + MMC_DEV_NODE_STATE_NO = 0, + MMC_DEV_NODE_STATE_EXIST = 1, + MMC_DEV_NODE_STATE_NO_EXIST = 2, +}MMC_DEV_NODE_STATE; + +typedef enum +{ + MMC_DEV_MOUNT_STATE_NO = 0, + MMC_DEV_MOUNT_STATE_MOUNTED = 1, + MMC_DEV_MOUNT_STATE_UNMOUNTED = 2, +}MMC_DEV_MOUNT_STATE; + +typedef enum +{ + MMC_DEV_SPACE_STATE_NO = 0, + MMC_DEV_SPACE_STATE_ENOUGH = 1, + MMC_DEV_SPACE_STATE_NO_ENOUGH = 2, +}MMC_DEV_SPACE_STATE; + +typedef enum +{ + MMC_DEV_LOOP_STATE_NO = 0, + MMC_DEV_LOOP_STATE_ON = 1, + MMC_DEV_LOOP_STATE_OFF = 2, +}MMC_DEV_LOOP_STATE; + +typedef struct +{ + MMC_DEV_TYPE dev_type; + MMC_DEV_NODE_STATE node; + MMC_DEV_MOUNT_STATE moumted_state; + MMC_DEV_SPACE_STATE space_state; + MMC_DEV_LOOP_STATE loop_state; + int dcf_handle; +}SF_ST_MMC_DEV; + + +void SF_StrgInit(void); +void SF_StrgUnInit(void); +void SF_StrgSetDcfHandle(UINT32 strg_id, UINT32 handle); +void SF_StrgRegister(SF_MESSAGE_BUF_S *pMessageBuf); +SF_ST_MMC_DEV *SF_StrgCheckWorkableDev(void); + + + +#endif //_SF_SYS_STRG_MNG_H_ + diff --git a/code/application/source/cardv/SrcCode/System/SysStrg_CB.c b/code/application/source/cardv/SrcCode/System/SysStrg_CB.c index 35e2b2872..83e77adef 100755 --- a/code/application/source/cardv/SrcCode/System/SysStrg_CB.c +++ b/code/application/source/cardv/SrcCode/System/SysStrg_CB.c @@ -42,6 +42,7 @@ #include #include #include "sf_sd_common.h" +#include "SF_SysStrgMng.h" #endif void Strg_CB(UINT32 event, UINT32 param1, UINT32 param2); @@ -52,7 +53,8 @@ void Strg_CB(UINT32 event, UINT32 param1, UINT32 param2) #if HUNTING_CAMERA_MCU == ENABLE SF_MESSAGE_BUF_S stMessageBuf = {0}; #endif - + + DBG_IND("Strg_CB: strg_id = %d, status = %d\n", param1, param2); switch (event) { // part-1 case SYSTEM_CB_CONFIG: @@ -175,6 +177,8 @@ void Strg_CB(UINT32 event, UINT32 param1, UINT32 param2) stMessageBuf.arg3 = param2; stMessageBuf.cmdId = CMD_SD; sf_com_message_send_to_app(&stMessageBuf); + printf("strg_cb send MOUNT! dev_id = %d\n", param1); + SF_StrgRegister(&stMessageBuf); } #endif diff --git a/code/application/source/cardv/SrcCode/System/SysStrg_Exe.c b/code/application/source/cardv/SrcCode/System/SysStrg_Exe.c index 9258db29f..705b5fc53 100644 --- a/code/application/source/cardv/SrcCode/System/SysStrg_Exe.c +++ b/code/application/source/cardv/SrcCode/System/SysStrg_Exe.c @@ -83,6 +83,8 @@ #include "userlog.h" #endif //#include "wdt.h" +#include "SF_SysStrgMng.h" + #if defined(_EMBMEM_SPI_NOR_) #define MAX_BLK_PER_SEC 128 @@ -329,6 +331,7 @@ static UINT32 gLogFile_Buff2_Size = sizeof(gLogFile_Buff2); void System_OnStrgInit_FS(void) { CHAR mount_path[KFS_LONGNAME_PATH_MAX_LENG] = {0}; + TM_BOOT_BEGIN("sdio", "init_fs"); { MEM_RANGE Pool; @@ -346,6 +349,8 @@ void System_OnStrgInit_FS(void) #endif } + SF_StrgInit();// 初始化sf_mmc设备Obj + #if !defined(__FREERTOS) GxStrg_SetConfigEx(STRG_ID_SD, FILE_CFG_FS_TYPE, FileSys_GetOPS_Linux()); //for FILE_CFG_FS_TYPE, DevID is don't care @@ -420,7 +425,6 @@ void System_OnStrgInit_FS(void) cfg.LogBuffSize2 = gLogFile_Buff2_Size; #endif LogFile_Config(&cfg); - DBG_DUMP("LogFile_Config ...\n"); } #endif @@ -526,6 +530,8 @@ void System_OnStrgExit_FS(void) #endif #endif + + SF_StrgUnInit();// 反初始化sf_mmc设备Obj // unmount file system GxStrg_CloseDevice(0); #if (FS_MULTI_STRG_FUNC) @@ -734,7 +740,6 @@ INT32 System_Set_Storage_Act_Drive(char drive) { DCF_HANDLE act_handle = -1; - for(int i=0 ; idcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return -1; } - - return g_dcf_hdl_act; + DBG_WRN("DCF_GET_HANDLE, %d\n", mmc_dev->dcf_handle); + return mmc_dev->dcf_handle; } CHAR System_Get_DCF_Disk_Drive(DCF_HANDLE handle) @@ -799,6 +807,8 @@ INT32 System_OnStrgInsert(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) char *pMountPath = "/mnt/sd"; #endif + DBG_DUMP("System_OnStrgInsert: strg_id = %d\n", strg_id); + if (m_BootState_Drive[strg_id] != BOOT_CARD_STATE_UNKNOWN) { if (strg_id == 0) { #if(IPCAM_FUNC==DISABLE && SDHOTPLUG_FUNCTION == DISABLE) @@ -844,7 +854,8 @@ INT32 System_OnStrgInsert(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) return NVTEVT_CONSUME; } } - else if(strg_id == STRG_ID_EMMC){ + else if(strg_id == STRG_ID_EMMC) + { DX_HANDLE pStrgDev = (DX_HANDLE)emmc_getStorageObject(STRG_OBJ_FAT1); if (GxStrg_OpenDevice(strg_id, pStrgDev) != TRUE) { char *pDxName = "unknown"; @@ -895,18 +906,24 @@ INT32 System_OnStrgInsert(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) * init dcf act handle with sd card *****************************************************************/ if(strg_id == STRG_ID_SD){ + DBG_WRN("sd act\n"); System_Set_Storage_Act_Drive(g_strg_mapping_table[strg_id].drive); } + else if(strg_id == STRG_ID_EMMC){ + DBG_WRN("emmc act\n"); + System_Set_Storage_Act_Drive(g_strg_mapping_table[strg_id].drive); + } + SF_StrgSetDcfHandle(strg_id, g_strg_mapping_table[strg_id].dcf_hdl); //获取mmc设备dcf_handle } #endif if(strg_id == STRG_ID_SD){ if (GxStrg_GetDeviceCtrl(strg_id, CARD_READONLY)) { System_SetState(SYS_STATE_CARD, CARD_LOCKED); - DBG_IND("Card Locked\r\n"); + DBG_WRN("Card Locked\r\n"); } else { System_SetState(SYS_STATE_CARD, CARD_INSERTED); - DBG_IND("Card inserted\r\n"); + DBG_WRN("Card inserted\r\n"); } } /************************************************ @@ -1034,6 +1051,7 @@ INT32 System_OnStrgAttach(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) ////////////////////////////////////////////////// #endif + //DBG_IND("System_OnStrgAttach: strg_id = %d\n", strg_id); if (m_GxStrgType == FST_FS_TYPE_LINUX) { //Do Nothing } else { //m_GxStrgType == FST_FS_TYPE_UITRON @@ -1095,10 +1113,12 @@ INT32 System_OnStrgAttach(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) if((CMD_FORMAT_SD_STA != sf_get_card_statu())){ stMessageBuf.arg1 = STRG_CB_MOUNT_FINISH; - stMessageBuf.arg2 = result; + stMessageBuf.arg2 = strg_id;//result; stMessageBuf.arg3 = FST_STA_OK; stMessageBuf.cmdId = CMD_SD; sf_com_message_send_to_app(&stMessageBuf); + SF_StrgRegister(&stMessageBuf); + printf("System_OnStrgAttach send MOUNT! dev_id = %d\n", strg_id); Ux_PostEvent(NVTEVT_STRG_MOUNT_OK, 0); } #endif @@ -1140,7 +1160,7 @@ INT32 System_OnStrgAttach(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) logOpenParm.maxFileNum = maxFileNum; logOpenParm.maxFileSize = maxFileSize; - logOpenParm.isPreAllocAllFiles = FALSE; + logOpenParm.isPreAllocAllFiles = TRUE; #if defined(__FREERTOS) logOpenParm.isSaveLastTimeSysErrLog = wdt_getResetNum()>0 ? TRUE : FALSE; #else //defined(__LINUX_USER__) @@ -1189,8 +1209,11 @@ INT32 System_OnStrgAttach(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) if((FS_DISK_ERROR == System_GetState(SYS_STATE_FS))){ stMessageBuf.arg1 = CMD_SD_STRG_CB_UNMOUNT_FINISH; + stMessageBuf.arg2 = strg_id; stMessageBuf.cmdId = CMD_SD; sf_com_message_send_to_app(&stMessageBuf); + SF_StrgRegister(&stMessageBuf); + printf("System_OnStrgAttach send UNMOUNT! dev_id = %d\n", strg_id); } #endif #if (POWERON_FAST_BOOT == ENABLE) diff --git a/code/application/source/cardv/SrcCode/System/SysStrg_Exe.c.bak b/code/application/source/cardv/SrcCode/System/SysStrg_Exe.c.bak new file mode 100755 index 000000000..179b9b53a --- /dev/null +++ b/code/application/source/cardv/SrcCode/System/SysStrg_Exe.c.bak @@ -0,0 +1,1593 @@ +/* + System Storage Callback + + System Callback for Storage Module. + + @file SysStrg_Exe.c + @ingroup mIPRJSYS + + @note �o���ɮ׭t�d�@��� + + 1.����Storage Event������ + �i�઺event��: + + STRG_INSERT --- �N���CARD���J + ����unmount���e�ݭn�����Ʊ� + �I�sFile unmound (NAND), + ����mount���e�ݭn�����Ʊ� + �I�sFile mount (CARD) + + STRG_REMOVE --- �N���CARD�ޥX + ����unmount���e�ݭn�����Ʊ� + �I�sFile unmount (CARD) + ����mount���e�ݭn�����Ʊ� + �I�sFile_mount (NAND) + + STRG_ATTACH --- �N��File mount���� + ����mount����ݭn�����Ʊ� + �o��|�ǤJmount�����Gstatus + + STRG_DETACH --- �N��File unmount���� + ����unmount����ݭn�����Ʊ� + �o��|�ǤJunmount�����Gstatus + + + Copyright Novatek Microelectronics Corp. 2010. All rights reserved. +*/ + +//////////////////////////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include +#include "PrjInc.h" +#include "PrjCfg.h" +//#include "sys_storage_partition.h" +//////////////////////////////////////////////////////////////////////////////// +#include "UIFrameworkExt.h" +#include "UICommon.h" +//#include "dma.h" +#include "PStore.h" +#include "sf_sd_common.h" +#if (USE_DCF == ENABLE) +#include "DCF.h" +#endif +//#include "ExifVendor.h" +#include "FileSysTsk.h" +#include "SysCommon.h" +#include "sys_mempool.h" +#include "DxType.h" +#include "Dx.h" +#include "DxApi.h" +#include "DxStorage.h" +#include +#include "FwSrvApi.h" +#include +#include +#include "GxStrg.h" +#include "sdio.h" +#include +#include +#include "emmc.h" +#if HUNTING_CAMERA_MCU == ENABLE +#include +#include +#include "sf_sd_common.h" +#endif +#if (LOGFILE_FUNC==ENABLE) +#include "LogFile.h" +#endif +#if (USERLOG_FUNC == ENABLE) +#include "userlog.h" +#endif +//#include "wdt.h" + +#if defined(_EMBMEM_SPI_NOR_) +#define MAX_BLK_PER_SEC 128 +#define MAX_SEC_NUM 8 +#else +#define MAX_BLK_PER_SEC 512 +#define MAX_SEC_NUM 64 +#endif +#define LDC_HEADER_SIZE 16 +#define FW_UPD_FW_TMP_MEM_SIZE 0xA00000 + +#define LOADER_UPD_FW_PATH "A:\\"_BIN_NAME_".BIN" +#define FW_DEL_INDIACTION_PATH "A:\\NVTDELFW" + +//#NT#2018/04/02#Niven Cho -begin +//#NT#PARTIAL_COMPRESS, we use last 10MB of APP as working buffer +#define FW_PARTIAL_COMPRESS_WORK_BUF_SIZE 0xA00000 +//#NT#2018/04/02#Niven Cho -end + +//global debug level: PRJ_DBG_LVL +#include "PrjCfg.h" +//local debug level: THIS_DBGLVL +#define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER +/////////////////////////////////////////////////////////////////////////////// +#define __MODULE__ SysStrgExe +#define __DBGLVL__ ((THIS_DBGLVL>=PRJ_DBG_LVL)?THIS_DBGLVL:PRJ_DBG_LVL) +#define __DBGFLT__ "*" //*=All, [mark]=CustomClass +#include +/////////////////////////////////////////////////////////////////////////////// +//Check definition options +#if defined(_CPU2_ECOS_) +#if (LOGFILE_FUNC == ENABLE && ECOS_DBG_MSG_FORCE_UART1_DIRECT == ENABLE) +//#error "LOGFILE_FUNC must turn off ECOS_DBG_MSG_FORCE_UART1_DIRECT" +#endif +#endif + +#if 0 +#define FW_UPDATE_FILE_LEN 16 +static char uiUpdateFWName[FW_UPDATE_FILE_LEN] = FW_UPDATE_NAME; +static BOOL m_bUpdRename = FALSE; +#endif + +#if (FS_FUNC == ENABLE) +static FST_FS_TYPE m_GxStrgType = FST_FS_TYPE_UITRON; +#endif +#if (FWS_FUNC == ENABLE) +static void *mp_fwsrv_work_buf = NULL; +#endif +static BOOL g_bSupportExfat = FALSE; +/////////////////////////////////////////////////////////////////////////////// +// +// EMBMEM +// +/////////////////////////////////////////////////////////////////////////////// +//Caculate FAT Start Addr +#if defined(_CPU2_LINUX_) +static BOOL xSysStrg_LinuxRun(void); +#endif +#if defined(_CPU2_ECOS_) +static BOOL xSysStrg_eCosRun(void); +#endif +#if (defined(_DSP1_FREERTOS_) || defined(_DSP2_FREERTOS_)) +static BOOL xSysStrg_DspRun(DSP_CORE_ID CoreID); +#endif + +#if (FWS_FUNC == ENABLE) +UINT32 System_OnStrgInit_EMBMEM_GetGxStrgType(void) +{ + return m_GxStrgType; +} + +void System_OnStrgInit_EMBMEM(void) +{ +#if defined(_EMBMEM_SPI_NOR_) + { + //if stoarge is SPI, use ram disk as internal FAT + DXSTRG_INIT UserEmbMemInit = {0}; + UserEmbMemInit.prt.uiDxClassType = DX_CLASS_STORAGE_EXT | USER_DX_TYPE_EMBMEM_FAT; + UserEmbMemInit.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_RAMDISK); + UserEmbMemInit.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_RAMDISK); + DX_HANDLE DxNandDev = Dx_GetObject(UserEmbMemInit.prt.uiDxClassType); + Dx_Init(DxNandDev, &UserEmbMemInit, 0, STORAGE_VER); + } +#endif +} + +void System_OnStrgExit_EMBMEM(void) +{ + //PHASE-1 : Close Drv or DrvExt +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// EXMEM +// +/////////////////////////////////////////////////////////////////////////////// +//Drv or DrvExt +#if (FS_FUNC == ENABLE) +DXSTRG_INIT UserSdioInit; +#if(COPYCARD2CARD_FUNCTION == ENABLE) +DXSTRG_INIT UserSdio2Init; +#endif +DX_HANDLE DxCardDev1 = 0; +typedef enum _BOOT_CARD_STATE { + BOOT_CARD_STATE_UNKNOWN, + BOOT_CARD_STATE_INSERTED, + BOOT_CARD_STATE_REMOVED, + ENUM_DUMMY4WORD(BOOT_CARD_STATE) +} BOOT_CARD_STATE; +static BOOT_CARD_STATE m_BootState_Drive[16] = {BOOT_CARD_STATE_UNKNOWN}; //DriveA, DriveB +static UINT32 m_FsDxTypeMap[2] = {FS_DX_TYPE_DRIVE_A, FS_DX_TYPE_DRIVE_B}; + +void System_OnStrgInit_EXMEM(void) +{ + static BOOL bStrg_init_EXMEM = FALSE; + if (bStrg_init_EXMEM) { + return; + } + TM_BOOT_BEGIN("sdio", "init"); + +#if (FS_DX_TYPE_DRIVE_A >= DX_TYPE_CARD1 && FS_DX_TYPE_DRIVE_A <= DX_TYPE_CARD3) + DX_HANDLE DxCardDev1 = Dx_GetObject(DX_CLASS_STORAGE_EXT | FS_DX_TYPE_DRIVE_A); + UserSdioInit.buf.addr = mempool_storage_sdio; + UserSdioInit.buf.size = POOL_SIZE_STORAGE_SDIO; + Dx_Init(DxCardDev1, &UserSdioInit, 0, STORAGE_VER); +#endif +#if (FS_MULTI_STRG_FUNC && FS_DX_TYPE_DRIVE_B >= DX_TYPE_CARD1 && FS_DX_TYPE_DRIVE_B <= DX_TYPE_CARD3) + DX_HANDLE DxCardDev2 = Dx_GetObject(DX_CLASS_STORAGE_EXT | FS_DX_TYPE_DRIVE_B); + UserSdio2Init.buf.Addr = OS_GetMempoolAddr(POOL_ID_STORAGE_SDIO2); + UserSdio2Init.buf.Size = OS_GetMempoolSize(POOL_ID_STORAGE_SDIO2); + Dx_Init(DxCardDev2, &UserSdio2Init, 0, STORAGE_VER); +#endif + bStrg_init_EXMEM = TRUE; + TM_BOOT_END("sdio", "init"); +} + +void System_OnStrgExit_EXMEM(void) +{ + //PHASE-1 : Close Drv or DrvExt + +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// FILESYS +// +/////////////////////////////////////////////////////////////////////////////// +//Lib or LibExt +#if (FS_FUNC == ENABLE) + +extern void Strg_CB(UINT32 event, UINT32 param1, UINT32 param2); +void Card_DetInsert(void); +void Card_DetBusy(void); +#if (LOGFILE_FUNC==ENABLE) +void System_DetErr(void); +#endif +#if (SDINSERT_FUNCTION == ENABLE) +SX_TIMER_ITEM(Card_DetInsert, Card_DetInsert, 2, FALSE) +#endif +SX_TIMER_ITEM(System_DetBusy, Card_DetBusy, 25, FALSE) +#if (LOGFILE_FUNC==ENABLE) +SX_TIMER_ITEM(System_DetErr, System_DetErr,50, FALSE) +#endif +int SX_TIMER_DET_STRG_ID = -1; +int SX_TIMER_DET_SYSTEM_BUSY_ID = -1; +#if (LOGFILE_FUNC==ENABLE) +int SX_TIMER_DET_SYSTEM_ERROR_ID = -1; +#endif + +#if (LOGFILE_FUNC==ENABLE) +#if defined(__FREERTOS) +_ALIGNED(64) static CHAR gLogFile_Buff[LOGFILE_BUFFER_SIZE]= {0}; +static UINT32 gLogFile_Buff_Size = sizeof(gLogFile_Buff); +#else //defined(__LINUX_USER__) +#include +#include +/* begin/end dma-buf functions used for userspace mmap. */ +struct dma_buf_sync { + unsigned long long flags; +}; +#define DMA_BUF_SYNC_READ (1 << 0) +#define DMA_BUF_SYNC_WRITE (2 << 0) +#define DMA_BUF_SYNC_RW (DMA_BUF_SYNC_READ | DMA_BUF_SYNC_WRITE) +#define DMA_BUF_SYNC_START (0 << 2) +#define DMA_BUF_SYNC_END (1 << 2) +#define DMA_BUF_SYNC_VALID_FLAGS_MASK \ + (DMA_BUF_SYNC_RW | DMA_BUF_SYNC_END) +#define DMA_BUF_BASE 'b' +#define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync) +#define LOGFILE_BASE 'l' +#define LOGFILE_IOCTL_FD _IOR(LOGFILE_BASE, 0, int) + +static CHAR *gLogFile_Buff = NULL; +static UINT32 gLogFile_Buff_Size = 0; + +static void logfile_init_dma_buff(void) +{ + int fd; + + fd = open("/dev/logfile", O_RDWR | O_CLOEXEC); + if (fd < 0) { + printf("open /dev/logfile failed, %s\n", strerror(errno)); + return; + } + + gLogFile_Buff = mmap(NULL, LOGFILE_BUFFER_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (gLogFile_Buff == MAP_FAILED) { + printf("mmap dmabuf failed: %s\n", strerror(errno)); + return; + } + gLogFile_Buff_Size = LOGFILE_BUFFER_SIZE; + + close(fd); +} +#endif +#if defined(_CPU2_LINUX_) +_ALIGNED(64) static CHAR gLogFile_Buff2[LOGFILE_BUFFER_SIZE]= {0}; +static UINT32 gLogFile_Buff2_Size = sizeof(gLogFile_Buff2); +#endif +#endif + +void System_OnStrgInit_FS(void) +{ + CHAR mount_path[KFS_LONGNAME_PATH_MAX_LENG] = {0}; + TM_BOOT_BEGIN("sdio", "init_fs"); + { + MEM_RANGE Pool; + Pool.addr = mempool_filesys; +#if (FS_MULTI_STRG_FUNC == ENABLE) + MEM_RANGE Pool2; + Pool.size = POOL_SIZE_FILESYS; + GxStrg_SetConfigEx(0, FILE_CFG_BUF, (UINT32)&Pool); + Pool2.addr = Pool.addr + POOL_SIZE_FILESYS; + Pool2.size = POOL_SIZE_FILESYS; + GxStrg_SetConfigEx(1, FILE_CFG_BUF, (UINT32)&Pool2); +#if defined(_CPU2_LINUX_) && defined(_EMBMEM_EMMC_) + // 3rd is for linux-pstore mounted by filesys + MEM_RANGE Pool3; + Pool3.Addr = Pool2.Addr + POOL_SIZE_FS_BUFFER; + Pool3.Size = POOL_SIZE_FS_BUFFER; + GxStrg_SetConfigEx(PST_DEV_ID, FILE_CFG_BUF, (UINT32)&Pool3); +#endif +#else + Pool.size = POOL_SIZE_FILESYS; + GxStrg_SetConfigEx(0, FILE_CFG_BUF, (UINT32)&Pool); +#endif + } + + + //#NT#2017/06/02#Nestor Yang -begin + //#NT# Do not link uITRON if not use + //GxStrg_SetConfigEx(0, FILE_CFG_FS_TYPE, m_GxStrgType); +#if !defined(__FREERTOS) + GxStrg_SetConfigEx(0, FILE_CFG_FS_TYPE, FileSys_GetOPS_Linux()); //for FILE_CFG_FS_TYPE, DevID is don't care +#else + GxStrg_SetConfigEx(0, FILE_CFG_FS_TYPE, FileSys_GetOPS_uITRON()); +#endif + //#NT#2017/06/02#Nestor Yang -end +#if 0 +#if (LOGFILE_FUNC==ENABLE) + GxStrg_SetConfigEx(0, FILE_CFG_MAX_OPEN_FILE, 6); +#endif +#if (USERLOG_FUNC == ENABLE) + GxStrg_SetConfigEx(0, FILE_CFG_MAX_OPEN_FILE, 6); +#endif +#if (CURL_FUNC == ENABLE) + GxStrg_SetConfigEx(0, FILE_CFG_MAX_OPEN_FILE, 8); +#endif +#if (IPCAM_FUNC == DISABLE) + GxStrg_SetConfigEx(0, FILE_CFG_MAX_OPEN_FILE, 8); +#endif +#else + GxStrg_SetConfigEx(0, FILE_CFG_MAX_OPEN_FILE, 10); +#endif + + GxStrg_SetConfigEx(0, FILE_CFG_SUPPORT_EXFAT, TRUE); + g_bSupportExfat = TRUE; + //set the device node of msdc mode for emmc only +#if (defined(_EMBMEM_EMMC_) && !defined(__FREERTOS)) + emmc_set_dev_node("/dev/mmcblk2p5"); //This devicde node is related to storate-partition, it is last rootfslX logical partition. Using "cat /proc/nvt_info/emmc" to get. +#endif + + // mount path +#if (defined(_EMBMEM_EMMC_) && !defined(__FREERTOS)) + strncpy(mount_path, "/mnt/emmc1", sizeof(mount_path) - 1); +#else + strncpy(mount_path, "/mnt/sd", sizeof(mount_path) - 1); +#endif + mount_path[sizeof(mount_path) - 1] = '\0'; + GxStrg_SetConfigEx(0, FILE_CFG_MOUNT_PATH, (UINT32)mount_path); + +#if !defined(__FREERTOS) + GxStrg_SetConfigEx(0, FILE_CFG_STRG_OBJECT, (UINT32)Dx_GetObject(DX_CLASS_STORAGE_EXT | FS_DX_TYPE_DRIVE_A)); +#endif + + +#if (FS_MULTI_STRG_FUNC == ENABLE) + emmc_set_dev_node("/dev/mmcblk1p1"); /* msdc strg obj */ + strncpy(mount_path, "/mnt/sd2", sizeof(mount_path) - 1); + mount_path[sizeof(mount_path) - 1] = '\0'; + GxStrg_SetConfigEx(1, FILE_CFG_MOUNT_PATH, (UINT32)mount_path); + GxStrg_SetConfigEx(1, FILE_CFG_STRG_OBJECT, (UINT32)Dx_GetObject(DX_CLASS_STORAGE_EXT | FS_DX_TYPE_DRIVE_B)); +#endif + + + //#NT#2018/12/18#Philex Lin - begin + // unused now + #if 0 + // Enable 32MB alignment recording. + GxStrg_SetConfigEx(0, FILE_CFG_ALIGNED_SIZE, 32 * 1024 * 1024); + #endif + //#NT#2018/12/18#Philex Lin - end + +#if (LOGFILE_FUNC==ENABLE) + { + LOGFILE_CFG cfg = {0}; + #if 0 + // only store system error log + cfg.ConType = LOGFILE_CON_UART|LOGFILE_CON_MEM; + #else + // store normal log and system error log + #if defined(_MODEL_CARDV_HS880C_) + cfg.ConType = LOGFILE_CON_MEM|LOGFILE_CON_STORE; + #else + cfg.ConType = LOGFILE_CON_UART|LOGFILE_CON_STORE; + #endif + #endif + cfg.TimeType = LOGFILE_TIME_TYPE_DATETIME; + #if defined(__FREERTOS) + #else //defined(__LINUX_USER__) + logfile_init_dma_buff(); + #endif + cfg.LogBuffAddr = (UINT32)gLogFile_Buff; + cfg.LogBuffSize = gLogFile_Buff_Size; + #if defined(_CPU2_LINUX_) + cfg.LogBuffAddr2 = (UINT32)gLogFile_Buff2; + cfg.LogBuffSize2 = gLogFile_Buff2_Size; + #endif + LogFile_Config(&cfg); + } +#endif + + GxStrg_RegCB(Strg_CB); //Register CB function of GxStorage (NANR or CARD) + { + //1.�]�winit�� + //FileSys: + //2.�]�wCB��, + //3.���USxJob�A�� ---------> System Job + //4.���USxTimer�A�� ---------> Detect Job +#if (SDINSERT_FUNCTION == ENABLE) + ////if (m_GxStrgType == FST_FS_TYPE_UITRON) { + SX_TIMER_DET_STRG_ID = SxTimer_AddItem(&Timer_Card_DetInsert); + ////} +#endif +#if (LOGFILE_FUNC==ENABLE) + { + SX_TIMER_DET_SYSTEM_ERROR_ID = SxTimer_AddItem(&Timer_System_DetErr); + } +#endif + //SX_TIMER_DET_SYSTEM_BUSY_ID = SxTimer_AddItem(&Timer_System_DetBusy); + //5.���USxCmd�A�� ---------> Cmd Function + //System_AddSxCmd(Storage_OnCommand); //GxStorage + + //start scan + SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, TRUE); + SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, TRUE); + } + TM_BOOT_END("sdio", "init_fs"); + + if (m_GxStrgType == FST_FS_TYPE_UITRON) { +#if (FS_MULTI_STRG_FUNC) + UINT32 uiDxState = 0; + DX_HANDLE pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT | FS_DX_TYPE_DRIVE_B); + if (Dx_GetState((DX_HANDLE)pStrgDev, STORAGE_STATE_INSERT, &uiDxState) != DX_OK || uiDxState == FALSE) { + Ux_PostEvent(NVTEVT_STRG_REMOVE, 1, 1); + } else { + Ux_PostEvent(NVTEVT_STRG_INSERT, 1, 1); + } +#endif + } + +#if (USE_DCF == ENABLE) + { + // init DCF + +// CHAR pFolderName[9] = {0}; +// CHAR pFileName[5] = {0}; +// // init DCF FolderID/FileID with RTC data +// struct tm tm_cur = hwclock_get_time(TIME_ID_CURRENT); +// snprintf(pFolderName, sizeof(pFolderName), "%1d%02d%02d", tm_cur.tm_year % 0x0A, tm_cur.tm_mon, tm_cur.tm_mday); +// snprintf(pFileName, sizeof(pFileName), "%02d%02d", tm_cur.tm_hour, tm_cur.tm_min); +// //DCF dir-name +// DCF_SetDirFreeChars(pFolderName); +// //DCF file-name +// DCF_SetFileFreeChars(DCF_FILE_TYPE_ANYFORMAT, pFileName); +// +// //DCF format +// DCF_SetParm(DCF_PRMID_SET_VALID_FILE_FMT, DCF_SUPPORT_FORMAT); +// DCF_SetParm(DCF_PRMID_SET_DEP_FILE_FMT, DCF_FILE_TYPE_JPG | DCF_FILE_TYPE_WAV | DCF_FILE_TYPE_MPO); +// //TODO: [DCF] How to add an new format & its ext? + + DCF_SetParm(DCF_PRMID_REMOVE_DUPLICATE_FOLDER, TRUE); + DCF_SetParm(DCF_PRMID_REMOVE_DUPLICATE_FILE, TRUE); + DCF_SetParm(DCF_PRMID_SET_VALID_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_MP4|DCF_FILE_TYPE_MOV); + DCF_SetParm(DCF_PRMID_SET_DEP_FILE_FMT, DCF_FILE_TYPE_JPG|DCF_FILE_TYPE_WAV|DCF_FILE_TYPE_MPO); + DCF_SetDirFreeChars(DCF_DIR_NAME); + DCF_SetFileFreeChars(DCF_FILE_TYPE_ANYFORMAT, DCF_FILE_NAME); + } +#endif +} +void System_OnStrgInit_FS2(void) +{ + // update card status again + if (GxStrg_GetDeviceCtrl(0, CARD_READONLY)) { + System_SetState(SYS_STATE_CARD, CARD_LOCKED); + } else if (GxStrg_GetDeviceCtrl(0, CARD_INSERT)) { + System_SetState(SYS_STATE_CARD, CARD_INSERTED); + } else { + System_SetState(SYS_STATE_CARD, CARD_REMOVED); + } +} +void System_OnStrgInit_FS3(void) +{ + static BOOL bFirst = TRUE; + if (bFirst) { + TM_BOOT_BEGIN("sdio", "fdb_create"); + } +#if 0 +#if(MOVIE_MODE==ENABLE) + INT32 iCurrMode = System_GetBootFirstMode(); + if (iCurrMode == PRIMARY_MODE_MOVIE) { + FlowMovie_FileDBCreate_Fast(); + } +#endif +#endif + if (bFirst) { + TM_BOOT_END("sdio", "fdb_create"); + } + bFirst = FALSE; +} + +void System_OnStrgExit_FS(void) +{ + //PHASE-2 : Close Lib or LibExt +#if (LOGFILE_FUNC==ENABLE) + #if HUNTING_CAMERA_MCU == ENABLE + UIMenuStoreInfo *puiPara = sf_ui_para_get(); + if (puiPara->DebugMode) + { + LogFile_Close(); + } + #else + LogFile_Close(); + #endif + +#endif + // unmount file system + GxStrg_CloseDevice(0); +#if (FS_MULTI_STRG_FUNC) + GxStrg_CloseDevice(1); +#endif + +} + +#if (PWR_FUNC == ENABLE) +static BOOL FileSys_DetBusy(void) +{ + return (BOOL)((INT32)FileSys_GetParam(FST_PARM_TASK_STS, 0) == FST_STA_BUSY); +} +#endif + +void Card_DetInsert(void) +{ +#if defined(__FREERTOS) + GxStrg_Det(0, Dx_GetObject(DX_CLASS_STORAGE_EXT | FS_DX_TYPE_DRIVE_A)); +#if (0)//FS_MULTI_STRG_FUNC) + GxStrg_Det(1, Dx_GetObject(DX_CLASS_STORAGE_EXT | FS_DX_TYPE_DRIVE_B)); +#endif +#else + GxStrg_Det(0, 0); +#endif +} + +void Card_DetBusy(void) +{ +#if (PWR_FUNC == ENABLE) + static BOOL bBusyLED = FALSE; + + if (GxPower_GetControl(GXPWR_CTRL_SLEEP_LEVEL) <= 1 && (!GxPower_GetControl(GXPWR_CTRL_BATTERY_CHARGE_EN))) { + if (FileSys_DetBusy()) { + if (bBusyLED == FALSE) { + DBG_IND("System - busy\r\n"); + bBusyLED = TRUE; +#if (OUTPUT_FUNC == ENABLE) + GxLED_SetCtrl(KEYSCAN_LED_GREEN, SETLED_SPEED, GXLED_1SEC_LED_TOGGLE_CNT / 5); + GxLED_SetCtrl(KEYSCAN_LED_GREEN, TURNON_LED, FALSE); + GxLED_SetCtrl(KEYSCAN_LED_GREEN, SET_TOGGLE_LED, TRUE); +#endif + } + } else { + if (bBusyLED == TRUE) { + DBG_IND("System - not busy\r\n"); + bBusyLED = FALSE; +#if (OUTPUT_FUNC == ENABLE) + GxLED_SetCtrl(KEYSCAN_LED_GREEN, SET_TOGGLE_LED, FALSE); + GxLED_SetCtrl(KEYSCAN_LED_GREEN, TURNON_LED, FALSE); +#endif + } + } + } +#endif +} + +#if (FSCK_FUNC == ENABLE) +int search_str_in_file(char *path, char *str) +{ + FILE *fp = NULL; + UINT32 u32ize = 0; + int found = 0; + char *pStrSrc = NULL; + + fp = fopen(path, "r"); + if (fp) { + fseek(fp, 0, SEEK_END); + u32ize = ftell(fp); // take file size + fseek(fp, 0, SEEK_SET); // move to position zero + pStrSrc = (char *)malloc(u32ize * sizeof(char)); + + if (pStrSrc) { + fread(pStrSrc, 1, u32ize, fp); + if (strstr(pStrSrc, str)) { + found = 1; + } + free(pStrSrc); + } + + fclose(fp); + fp = NULL; + pStrSrc = NULL; + u32ize = 0; + } + + return found; +} + +int System_check_mmcblk0p1(void) +{ + SysMain_system("ls /dev/mmcblk0p1 > /tmp/lsdev.txt"); + vos_util_delay_ms(100); + if (search_str_in_file("/tmp/lsdev.txt", "/dev/mmcblk0p1")) { + return 1; + } else { + return 0; + } +} + +int System_mount_storage(char *pMountPath) +{ + int ret = 0; + time_t t, t_local, t_gmt; + struct tm tt_local, tt_gmt; + char opts[20]; + char *pDevSrc; + char *pFileSysType = "vfat"; + char *pFileSysExType = "exfat"; + BOOL bexfat = FALSE; + + if (System_check_mmcblk0p1()) { + pDevSrc = "/dev/mmcblk0p1"; + } else { + pDevSrc = "/dev/mmcblk0"; + } + + time(&t); + localtime_r(&t, &tt_local); + gmtime_r(&t, &tt_gmt); + t_local = mktime(&tt_local); + t_gmt = mktime(&tt_gmt); + + snprintf(opts, 19, "time_offset=%d", (t_local-t_gmt)/60); + DBG_IND("gtime=%d, ltime=%d, diff=%d, m=%d, %s\r\n", t_gmt, t_local, (t_local-t_gmt), (t_local-t_gmt)/60, opts); + + { + long long DevSize = 0; + int fd = 0; + long long size = 0; + + DevSize = 0;//set to zero first + + fd = open(pDevSrc, O_RDONLY); + if(fd < 0) { + DBG_ERR("open %s: errno = %d, errmsg = %s\r\n", pDevSrc, errno, strerror(errno)); + } else { + if(ioctl(fd, BLKGETSIZE64, &size) < 0) { + DBG_ERR("ioctl BLKGETSIZE64 failed\r\n"); + } + + if (0 != close(fd)) { + DBG_ERR("close %s: errno = %d, errmsg = %s\r\n", pDevSrc, errno, strerror(errno)); + } + } + + DBG_DUMP("%s: %s size = %lld\r\n", __func__, pDevSrc, size); + + DevSize = size; + + //original SD card + if(g_bSupportExfat && DevSize > 32*1024*1024*1024LL) + { + bexfat = TRUE; + } + else + { + bexfat = FALSE; + } + } + + // mount sd card + if (bexfat == FALSE) { + ret = mount(pDevSrc, pMountPath, pFileSysType, MS_DIRSYNC, opts); + } else { + ret = mount(pDevSrc, pMountPath, pFileSysExType, MS_DIRSYNC, opts); + } + + if(ret) { + if (errno == EBUSY) { + DBG_ERR("%s is existed, don't need to mount again\r\n", pMountPath); + } else { + DBG_ERR("mount /mnt/sd failed, errno = %d\r\n",errno); + } + } + + return ret; +} + +int System_umount_storage(char *pMountPath) +{ + int ret = 0; + + ret = umount(pMountPath); + + if (ret) { + if (errno == EBUSY) { + DBG_ERR("Catn't umount, please use 'lsof' to check the resource\r\n"); + } else if (errno == EINVAL) { + DBG_ERR("%s isn't existed, don't need to umount again\r\n", pMountPath); + } + } + + return ret; +} +#endif + + +INT32 System_OnStrgInsert(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) +{ + UINT32 stg_id = paramArray[0]; + #if (FSCK_FUNC == ENABLE) + int ret_val = 0; + char *pMountPath = "/mnt/sd"; + #endif + + if (m_BootState_Drive[stg_id] != BOOT_CARD_STATE_UNKNOWN) { + if (stg_id == 0) { +#if(IPCAM_FUNC==DISABLE && SDHOTPLUG_FUNCTION == DISABLE) + System_PowerOff(SYS_POWEROFF_NORMAL); +#endif + } + } else { + TM_BOOT_BEGIN("sdio", "mount_fs"); + m_BootState_Drive[stg_id] = BOOT_CARD_STATE_INSERTED; + } + + #if (FSCK_FUNC == ENABLE) + //SysMain_system("df"); //only for debug, the "/mnt/sd" path must not be existed. + System_umount_storage(pMountPath); + /*Under normal situation, fsck checking doesn't need to print the message via UART port. + We sotre the message to /tmp/fsck.txt (on DRAM). */ + if (System_check_mmcblk0p1()) { + DBG_IND("fsck /dev/mmcblk0p1\r\n"); + SysMain_system("fsck.fat -a /dev/mmcblk0p1 > /tmp/fsck.txt"); //Store to /tmp/fsck.txt and use "cat /tmp/fsck.txt". + //SysMain_system("fsck.fat -a /dev/mmcblk0p1"); //The fsck checking will print the message directly. + } else { + DBG_IND("no /dev/mmcblk0p1, try to fsck /dev/mmcblk0\r\n"); + SysMain_system("fsck.fat -a /dev/mmcblk0 > /tmp/fsck.txt"); //Store to /tmp/fsck.txt and use "cat /tmp/fsck.txt". + //SysMain_system("fsck.fat -a /dev/mmcblk0"); //The fsck checking will print the message directly. + } + + ret_val = System_mount_storage(pMountPath); + if (ret_val) { + GxStrg_SetStrgMountStatus(stg_id, FALSE); + DBG_ERR("mount /mnt/sd failed, ret_val is %d; errno = %d\r\n", ret_val, errno); + } else { + GxStrg_SetStrgMountStatus(stg_id, TRUE); + } + //SysMain_system("df"); //only for debug, the "/mnt/sd" path must be existed. + #endif + + // linux partition as PStore + if (stg_id == PST_DEV_ID) { +#if defined(_CPU2_LINUX_) + if (GxStrg_OpenDevice(stg_id, NULL) != TRUE) { + DBG_ERR("Storage mount pstore fail\r\n"); + } + return NVTEVT_CONSUME; +#else + DBG_FATAL("stg_id cannot be %d.\r\n", PST_DEV_ID); +#endif + } + + DX_HANDLE pStrgDev = (DX_HANDLE)sdio_getStorageObject(STRG_OBJ_FAT1); + if (GxStrg_OpenDevice(stg_id, pStrgDev) != TRUE) { + char *pDxName = "unknown"; + Dx_GetInfo(pStrgDev, DX_INFO_NAME, &pDxName); + DBG_ERR("Storage mount %s fail\r\n", pDxName); + return NVTEVT_CONSUME; + } + +#if (USE_DCF == ENABLE) + { + DCF_OPEN_PARM dcfParm = {0}; + // Open DCF + dcfParm.Drive = (stg_id == 0) ? 'A' : 'B'; +#if (FS_MULTI_STRG_FUNC) +// if (POOL_CNT_DCF_BUFFER !=2) { +// DBG_FATAL("POOL_CNT_DCF_BUFFER be 2 for FS_MULTI_STRG_FUNC.\r\n"); +// } else { + switch(stg_id) { + case 0: +// dcfParm.WorkbuffAddr = dma_getCacheAddr(OS_GetMempoolAddr(POOL_ID_DCF_BUFFER)); + dcfParm.WorkbuffAddr = mempool_dcf; + break; + case 1: +// dcfParm.WorkbuffAddr = dma_getCacheAddr(OS_GetMempoolAddr(POOL_ID_DCF_BUFFER)) + POOL_SIZE_DCF_BUFFER; + dcfParm.WorkbuffAddr = mempool_dcf + POOL_SIZE_DCF_BUFFER; + break; + default: + DBG_ERR("unknown stg_id=%d\r\n", stg_id); + dcfParm.WorkbuffAddr = 0; + break; + } +// } +#else + + dcfParm.WorkbuffAddr = mempool_dcf;//dma_getCacheAddr(OS_GetMempoolAddr(POOL_ID_DCF_BUFFER)); +#endif + + dcfParm.WorkbuffSize = POOL_SIZE_DCF_BUFFER; + + UINT32 handle = DCF_Open(&dcfParm); + + DBG_DUMP("Handle = %lu, drive = %c\n", handle, dcfParm.Drive); + // DCF_ScanObj(); + } +#endif + if(stg_id == 0){ + if (GxStrg_GetDeviceCtrl(stg_id, CARD_READONLY)) { + System_SetState(SYS_STATE_CARD, CARD_LOCKED); + DBG_IND("Card Locked\r\n"); + } else { + System_SetState(SYS_STATE_CARD, CARD_INSERTED); + DBG_IND("Card inserted\r\n"); + } + } + return NVTEVT_CONSUME; +} + + +INT32 System_OnStrgRemove(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) +{ + UINT32 stg_id = paramArray[0]; + if (m_BootState_Drive[stg_id] != BOOT_CARD_STATE_UNKNOWN) { + if (stg_id == 0) { +#if (LOGFILE_FUNC==ENABLE) + #if HUNTING_CAMERA_MCU == ENABLE + UIMenuStoreInfo *puiPara = sf_ui_para_get(); + if (puiPara->DebugMode) + { + LogFile_Suspend(); + LogFile_Close(); + } + #else + LogFile_Suspend(); + LogFile_Close(); + #endif + +#endif +#if (USERLOG_FUNC == ENABLE) + { + userlog_close(); + } +#endif +#if (USE_DCF == ENABLE) + //Fix the error "DCF_GetInfoByHandle() Dcf Handle 0 Data may be overwritted" when card plug out/in + DCF_Close(0); +#endif + System_SetState(SYS_STATE_CARD, CARD_REMOVED); + + GxStrg_CloseDevice(stg_id); +#if(IPCAM_FUNC==DISABLE && SDHOTPLUG_FUNCTION == DISABLE) + System_PowerOff(SYS_POWEROFF_NORMAL); +#endif + } + } else { + TM_BOOT_BEGIN("sdio", "mount_fs"); + m_BootState_Drive[stg_id] = BOOT_CARD_STATE_REMOVED; + #if (FS_SWITCH_STRG_FUNC == ENABLE) + if (stg_id==0) { + DX_HANDLE pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT|FS_DX_TYPE_DRIVE_B); + if (GxStrg_OpenDevice(stg_id, pStrgDev)!= TRUE) { + char* pDxName="unknown"; + Dx_GetInfo(pStrgDev, DX_INFO_NAME,&pDxName); + DBG_ERR("Storage mount %s fail\r\n",pDxName); + return NVTEVT_CONSUME; + } + System_SetState(SYS_STATE_CARD, CARD_INSERTED); + return NVTEVT_CONSUME; + } + #else + // boot without card, send attach to continue UI flow. + // because of UserWaitEvent(NVTEVT_STRG_ATTACH, ¶mNum, paramArray); + Ux_PostEvent(NVTEVT_STRG_ATTACH, 2, stg_id, 0xFF); + #endif + } + + DX_HANDLE pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT | m_FsDxTypeMap[stg_id]); + if (GxStrg_CloseDevice(stg_id) != TRUE) { + char *pDxName = "unknown"; + Dx_GetInfo(pStrgDev, DX_INFO_NAME, &pDxName); + DBG_ERR("Storage mount %s fail\r\n", pDxName); + return NVTEVT_CONSUME; + } + + return NVTEVT_CONSUME; +} + +INT32 System_OnStrgAttach(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) +{ + #if defined(__FREERTOS) + SHMINFO *p_shm; + unsigned char *p_fdt = (unsigned char *)fdt_get_base(); + int len; + int nodeoffset; + const void *nodep; /* property node pointer */ + unsigned int *p_data; + #endif + UINT32 result = paramArray[1]; + #if HUNTING_CAMERA_MCU == ENABLE + SF_MESSAGE_BUF_S stMessageBuf = {0}; + UINT32 strg_id = paramArray[0]; + + #endif +#if defined(__FREERTOS) + if (p_fdt== NULL) { + DBG_ERR("p_fdt is NULL.\n"); + return NVTEVT_CONSUME; + } + + // read SHMEM_PATH + nodeoffset = fdt_path_offset(p_fdt, SHMEM_PATH); + if (nodeoffset < 0) { + DBG_ERR("failed to offset for %s = %d \n", SHMEM_PATH, nodeoffset); + } else { + DBG_DUMP("offset for %s = %d \n", SHMEM_PATH, nodeoffset); + } + nodep = fdt_getprop(p_fdt, nodeoffset, "reg", &len); + if (len == 0 || nodep == NULL) { + DBG_ERR("failed to access reg.\n"); + return NVTEVT_CONSUME; + } else { + p_data = (unsigned int *)nodep; + p_shm = (SHMINFO *)be32_to_cpu(p_data[0]); + DBG_DUMP("p_shm = 0x%08X\n", (int)p_shm); + } + ////////////////////////////////////////////////// +#endif + + if (m_GxStrgType == FST_FS_TYPE_LINUX) { + //Do Nothing + } else { //m_GxStrgType == FST_FS_TYPE_UITRON + //if spi use RamDisk as inner Memory,need to format RamDisk +#if defined(_EMBMEM_SPI_NOR_) + FS_HANDLE pStrgDevCur = (FS_HANDLE)GxStrg_GetDevice(0); + FS_HANDLE pStrgDevRAM = (FS_HANDLE)Dx_GetObject(DX_CLASS_STORAGE_EXT | USER_DX_TYPE_EMBMEM_FAT); + + if ((pStrgDevCur == pStrgDevRAM) && (result != FST_STA_OK)) { + result = FileSys_FormatDisk(pStrgDevCur, TRUE); + } +#endif + } + + DBG_WRN("stg_id = %lu\n", paramArray[0]); + + switch (result) { + case FST_STA_OK: + printf("read only = %llu\n", FileSys_GetDiskInfoEx('A', FST_INFO_IS_READ_ONLY)); + if(FileSys_GetDiskInfoEx('A', FST_INFO_IS_READ_ONLY)){ + system("mount -t vfat /dev/mmcblk0 /mnt/sd/ -o remount,rw"); + } +//#if (USE_DCF == ENABLE) +// if (!UI_GetData(FL_IsCopyToCarding)) { + DCF_ScanObj(); +// } +//#endif + //FileSys_GetDiskInfo(FST_INFO_DISK_SIZE); + System_SetState(SYS_STATE_FS, FS_INIT_OK); + + #if HUNTING_CAMERA_MCU == ENABLE + INT32 uiStatus = 0; + UINT8 ucAttrib = 0; + uiStatus = FileSys_GetAttrib(PHOTO_THUMB_PATH, &ucAttrib); + if (uiStatus == FST_STA_OK) { + if(!(ucAttrib&FST_ATTRIB_HIDDEN)){ + #if SF_IQ_TEST != ENABLE + FileSys_SetAttrib(PHOTO_THUMB_PATH, FST_ATTRIB_HIDDEN/* | FST_ATTRIB_SYSTEM*/, TRUE); + #endif + } + } + else { + FileSys_MakeDir(PHOTO_THUMB_PATH); + #if SF_IQ_TEST != ENABLE + FileSys_SetAttrib(PHOTO_THUMB_PATH, FST_ATTRIB_HIDDEN/* | FST_ATTRIB_SYSTEM*/, TRUE); + #endif + } + #if HUNTING_CAMERA_MCU == ENABLE + + if((CMD_FORMAT_SD_STA != sf_get_card_statu())){ + stMessageBuf.arg1 = STRG_CB_MOUNT_FINISH; + stMessageBuf.arg2 = result; + stMessageBuf.arg3 = FST_STA_OK; + stMessageBuf.cmdId = CMD_SD; + sf_com_message_send_to_app(&stMessageBuf); + Ux_PostEvent(NVTEVT_STRG_MOUNT_OK, 0); + } + #endif + #endif +#if defined(__FREERTOS) + if (p_shm && p_shm->boot.LdCtrl2 & LDCF_UPDATE_FW) { + FST_FILE hFile = FileSys_OpenFile(FW_DEL_INDIACTION_PATH, FST_OPEN_READ | FST_OPEN_EXISTING); + if (hFile != NULL) { + DBG_DUMP("Detected %s, delete %s \r\n", FW_DEL_INDIACTION_PATH, LOADER_UPD_FW_PATH); + FileSys_CloseFile(hFile); + // Delete FW bin from A: + if (FileSys_DeleteFile(LOADER_UPD_FW_PATH) != FST_STA_OK) { + DBG_ERR("delete "_BIN_NAME_".BIN failed .\r\n"); + } + if (FileSys_DeleteFile(FW_DEL_INDIACTION_PATH) != FST_STA_OK) { + DBG_ERR("delete %s failed .\r\n", FW_DEL_INDIACTION_PATH); + } + } + } +#endif + +#if (LOGFILE_FUNC==ENABLE) + #if HUNTING_CAMERA_MCU == ENABLE + UIMenuStoreInfo *puiPara = sf_ui_para_get(); + + if ((puiPara->DebugMode) && SxTimer_GetFuncActive(SX_TIMER_DET_SYSTEM_ERROR_ID) == 0) + #else + if (SxTimer_GetFuncActive(SX_TIMER_DET_SYSTEM_ERROR_ID) == 0) + #endif + { + LOGFILE_OPEN logOpenParm = {0}; + UINT32 maxFileNum = 32; + UINT32 maxFileSize = 0x100000; // 1MB + CHAR rootDir[LOGFILE_ROOT_DIR_MAX_LEN + 1] = "A:\\LOG\\"; + #if defined(_CPU2_LINUX_) + CHAR rootDir2[LOGFILE_ROOT_DIR_MAX_LEN + 1] = "A:\\Novatek\\LOG2\\"; + #endif + CHAR sysErrRootDir[LOGFILE_ROOT_DIR_MAX_LEN + 1] = "A:\\SYS\\"; + + logOpenParm.maxFileNum = maxFileNum; + logOpenParm.maxFileSize = maxFileSize; + logOpenParm.isPreAllocAllFiles = TRUE; + #if defined(__FREERTOS) + logOpenParm.isSaveLastTimeSysErrLog = wdt_getResetNum()>0 ? TRUE : FALSE; + #else //defined(__LINUX_USER__) + logOpenParm.isSaveLastTimeSysErrLog = FALSE; + #endif + logOpenParm.lastTimeSysErrLogBuffAddr = mempool_logfile; + logOpenParm.lastTimeSysErrLogBuffSize = POOL_SIZE_LOGFILE; + strncpy(logOpenParm.rootDir, rootDir, LOGFILE_ROOT_DIR_MAX_LEN); + #if defined(_CPU2_LINUX_) + strncpy(logOpenParm.rootDir2, rootDir2, LOGFILE_ROOT_DIR_MAX_LEN); + #endif + strncpy(logOpenParm.sysErrRootDir, sysErrRootDir, LOGFILE_ROOT_DIR_MAX_LEN); + logOpenParm.isZeroFile = TRUE; + LogFile_Open(&logOpenParm); + + //start scan + SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_ERROR_ID, TRUE); + + } +#endif +#if (USERLOG_FUNC == ENABLE) + { + userlog_open(); + } +#endif + break; + case FST_STA_DISK_UNFORMAT: + if(strg_id == 0) + System_SetState(SYS_STATE_FS, FS_UNFORMATTED); + break; + case FST_STA_DISK_UNKNOWN_FORMAT: + if(strg_id == 0) + System_SetState(SYS_STATE_FS, FS_UNKNOWN_FORMAT); + break; + case FST_STA_CARD_ERR: + if(strg_id == 0) + System_SetState(SYS_STATE_FS, FS_DISK_ERROR); + break; + default: + if(strg_id == 0) + System_SetState(SYS_STATE_FS, FS_DISK_ERROR); + break; + } + + #if HUNTING_CAMERA_MCU == ENABLE + + if((FS_DISK_ERROR == System_GetState(SYS_STATE_FS))){ + stMessageBuf.arg1 = CMD_SD_STRG_CB_UNMOUNT_FINISH; + stMessageBuf.cmdId = CMD_SD; + sf_com_message_send_to_app(&stMessageBuf); + } + #endif +#if (POWERON_FAST_BOOT == ENABLE) + INIT_SETFLAG(FLGINIT_STRGATH); +#endif + Ux_PostEvent(NVTEVT_STORAGE_INIT, 0, 0); +#if (PWR_FUNC == ENABLE) + GxPower_SetControl(GXPWR_CTRL_AUTOSLEEP_EN, 0xff); //reset +#endif + return NVTEVT_CONSUME; +} + +INT32 System_OnStrgDetach(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray) +{ + if (m_GxStrgType == FST_FS_TYPE_LINUX) { + UINT32 stg_id = paramArray[0]; + + if (stg_id != 0) { //not sd-1 + return NVTEVT_CONSUME; + } + } + + switch (paramArray[1]) { + case FST_STA_OK: + DBG_IND("FS: unmount OK\r\n"); + break; + + default: + DBG_ERR("^RFS: unmount FAIL\r\n"); + break; + } + return NVTEVT_CONSUME; +} + +BOOL gChkCardPwrOn = FALSE; +BOOL gChkCardChange = FALSE; + +void Storage_PowerOn_Start(void) +{ + gChkCardPwrOn = GxStrg_GetDeviceCtrl(0, CARD_INSERT); + DBG_IND("^BStg Power On = %d\r\n", gChkCardPwrOn); +} +void Storage_UpdateSource(void) +{ + DBG_IND("^Y-------------CARD det\r\n"); + if (gChkCardPwrOn) { + if (FALSE == GxStrg_GetDeviceCtrl(0, CARD_INSERT)) { //CARD�w�ް� + gChkCardChange = TRUE; + } + } else { + if (TRUE == GxStrg_GetDeviceCtrl(0, CARD_INSERT)) { //CARD�w���J + gChkCardChange = TRUE; + } + } +} +void Storage_PowerOn_End(void) +{ + Storage_UpdateSource(); + gChkCardPwrOn = GxStrg_GetDeviceCtrl(0, CARD_INSERT); + + if (TRUE == gChkCardChange) { //CARD���g���� + System_PowerOff(SYS_POWEROFF_NORMAL); //���� + return; + } +} + + +/////////////////////////////////////////////////////////////////////////////// +// +// PSTORE +// +/////////////////////////////////////////////////////////////////////////////// +#if (PST_FUNC == ENABLE) +#define PST_IND_FILE "/mnt/pstore/.psinit" + +void System_PS_Format(void) +{ + PSFMT gFmtStruct = {MAX_BLK_PER_SEC, MAX_SEC_NUM}; + PStore_Format(&gFmtStruct); +} +void System_OnStrgInit_PS(void) +{ + struct stat st; + char ind_file_name[64]; + + //PHASE-2 : Init & Open Lib or LibExt + TM_BOOT_BEGIN("nand", "init_ps"); +#if (PST_FUNC == ENABLE) + // Open PStore + PSFMT gFmtStruct = {MAX_BLK_PER_SEC, MAX_SEC_NUM}; + PSTORE_INIT_PARAM gPStoreParam; + UINT32 result = 0; +#if defined(__FREERTOS) + UINT8 *pBuf; +#endif +#if defined(_CPU2_LINUX_) && defined(_EMBMEM_EMMC_) + PStore_Init(PS_TYPE_FILESYS, PST_FS_DRIVE[0]); + UINT32 paramNum; + UINT32 paramArray[MAX_MESSAGE_PARAM_NUM]; + do { + UserWaitEvent(NVTEVT_STRG_ATTACH, ¶mNum, paramArray); + } while(paramArray[0] != PST_DEV_ID); //PStore will mount first before dev[0],dev[1] +#else + PStore_Init(PS_TYPE_EMBEDED, 0); +#endif +#if defined(__FREERTOS) + pBuf = (UINT8 *)mempool_pstore; + if(!pBuf){ + DBG_ERR("fail to allocate pstore buffer of %d bytes\n", POOL_SIZE_PS_BUFFER); + return; + } + + gPStoreParam.pBuf = pBuf; + gPStoreParam.uiBufSize = POOL_SIZE_PS_BUFFER; + DBG_DUMP("PStore uiBufSize=%d\r\n", gPStoreParam.uiBufSize); +#else + gPStoreParam.pBuf = NULL; + gPStoreParam.uiBufSize = 0; +#endif + result = PStore_Open(NULL, &gPStoreParam); + + if ((result != E_PS_OK) || (stat(PST_IND_FILE, &st) != 0)) { + DBG_ERR("PStore Open fail %d format \r\n", result); + // close pstore to umount pstore partition + PStore_Close(); + // after format, pstore partition will be re-mounted, so don't call open again + PStore_Format(&gFmtStruct); + // create indicated file + strncpy(ind_file_name, "touch ", 10); + strncat(ind_file_name, PST_IND_FILE, 50); + system(ind_file_name); + } + +#if defined(_CPU2_LINUX_) + { + PSTOREIPC_OPEN PsopenObj = {0}; + // open pstore ipc + PstoreIpc_Open(&PsopenObj); + } +#endif +#endif +#if (POWERON_FAST_BOOT == ENABLE) + INIT_SETFLAG(FLGINIT_MOUNTPS); +#endif + TM_BOOT_END("nand", "init_ps"); +} +void System_OnStrgExit_PS(void) +{ +#if (PST_FUNC == ENABLE) +#if defined(_CPU2_LINUX_) + PstoreIpc_Close(); +#endif + PStore_Close(); +#endif +} +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// FWSTORE +// +/////////////////////////////////////////////////////////////////////////////// +#if (FWS_FUNC == ENABLE) +#include "FileSysTsk.h" +#if (FWS_FUNC == ENABLE) +#include "FwSrvApi.h" +#endif +#include "MemCheck.h" + +typedef enum { + CODE_SECTION_01 = 0, + CODE_SECTION_02, + CODE_SECTION_03, + CODE_SECTION_04, + CODE_SECTION_05, + CODE_SECTION_06, + CODE_SECTION_07, + CODE_SECTION_08, + CODE_SECTION_09, + CODE_SECTION_10, + CODE_SECTION_11, + CODE_SECTION_12, + CODE_SECTION_13, + CODE_SECTION_14, + CODE_SECTION_15, + CODE_SECTION_16, + ENUM_DUMMY4WORD(_CODE_SECTION_) +} +CODE_SECTION; + +UINT32 UserSection_Load[10] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0}; +UINT32 UserSection_Order_full[] = { + CODE_SECTION_02, CODE_SECTION_03, CODE_SECTION_04, CODE_SECTION_05, CODE_SECTION_06, + CODE_SECTION_07, CODE_SECTION_08, CODE_SECTION_09, CODE_SECTION_10, FWSRV_PL_BURST_END_TAG +}; + +int order = 1; +void UserSection_LoadCb(const UINT32 Idx) +{ + DBG_DUMP("Section-%.2ld: (LOAD)\r\n", Idx + 1); + + UserSection_Load[Idx] = 1; //mark loaded + order++; + + if (Idx == 9) { //Section-10 + if (mp_fwsrv_work_buf) { + free(mp_fwsrv_work_buf); + mp_fwsrv_work_buf = NULL; + } + } +#if (POWERON_FAST_BOOT == ENABLE) + if (Idx == 0) { //Section-01 + INIT_SETFLAG(FLGINIT_LOADCODE1); + } + if (Idx == 1) { //Section-02 + INIT_SETFLAG(FLGINIT_LOADCODE2); + } + if (Idx == 2) { //Section-03 + INIT_SETFLAG(FLGINIT_LOADCODE3); + } + if (Idx == 9) { //Section-10 + } +#endif +} + +void System_OnStrgInit_FWS(void) +{ + SHMINFO *p_shm; + FWSRV_INIT Init = {0}; + unsigned char *p_fdt = (unsigned char *)fdt_get_base(); + + + if (p_fdt == NULL) { + DBG_ERR("p_fdt is NULL.\n"); + return; + } + + int len; + int nodeoffset; + const void *nodep; /* property node pointer */ + + // read SHMEM_PATH + nodeoffset = fdt_path_offset(p_fdt, SHMEM_PATH); + if (nodeoffset < 0) { + DBG_ERR("failed to offset for %s = %d \n", SHMEM_PATH, nodeoffset); + } else { + DBG_DUMP("offset for %s = %d \n", SHMEM_PATH, nodeoffset); + } + nodep = fdt_getprop(p_fdt, nodeoffset, "reg", &len); + if (len == 0 || nodep == NULL) { + DBG_ERR("failed to access reg.\n"); + return; + } else { + unsigned int *p_data = (unsigned int *)nodep; + p_shm = (SHMINFO *)be32_to_cpu(p_data[0]); + DBG_DUMP("p_shm = 0x%08X\n", (int)p_shm); + if (p_shm->boot.LdCtrl2 & LDCF_BOOT_CARD) { + DBG_DUMP(DBG_COLOR_HI_YELLOW"\r\nNotice: Boot from T.bin. app.dtb will load from flash!!!\r\n\r\n"DBG_COLOR_END); + } + } + + // init fwsrv + Init.uiApiVer = FWSRV_API_VERSION; + Init.StrgMap.pStrgFdt = EMB_GETSTRGOBJ(STRG_OBJ_FW_FDT); + Init.StrgMap.pStrgApp = EMB_GETSTRGOBJ(STRG_OBJ_FW_APP); + Init.StrgMap.pStrgUboot = EMB_GETSTRGOBJ(STRG_OBJ_FW_UBOOT); + Init.StrgMap.pStrgRtos = EMB_GETSTRGOBJ(STRG_OBJ_FW_RTOS); + Init.PlInit.uiApiVer = PARTLOAD_API_VERSION; + Init.PlInit.pStrg = EMB_GETSTRGOBJ(STRG_OBJ_FW_RTOS); +#if defined(_FW_TYPE_PARTIAL_COMPRESS_) + mp_fwsrv_work_buf = (void *)malloc(FW_PARTIAL_COMPRESS_WORK_BUF_SIZE); + Init.PlInit.DataType = PARTLOAD_DATA_TYPE_COMPRESS_GZ; + Init.PlInit.uiWorkingAddr = (UINT32)mp_fwsrv_work_buf; + Init.PlInit.uiWorkingSize = FW_PARTIAL_COMPRESS_WORK_BUF_SIZE ; + +#elif defined(_FW_TYPE_PARTIAL_) + mp_fwsrv_work_buf = (void *)malloc(_EMBMEM_BLK_SIZE_); + Init.PlInit.DataType = PARTLOAD_DATA_TYPE_UNCOMPRESS; + Init.PlInit.uiWorkingAddr = (UINT32)mp_fwsrv_work_buf; + Init.PlInit.uiWorkingSize = _EMBMEM_BLK_SIZE_ ; +#endif + Init.PlInit.uiAddrBegin = _BOARD_RTOS_ADDR_ + p_shm->boot.LdLoadSize; + FwSrv_Init(&Init); + FwSrv_Open(); +} + +void System_OnStrgExit_FWS(void) +{ +#if (FWS_FUNC == ENABLE) + ER er; + er = FwSrv_Close(); + if (er != FWSRV_ER_OK) { + DBG_ERR("Close failed!\r\n"); + } +#endif +} + +void System_CPU2_Start(void) +{ +} + +void System_CPU2_Stop(void) +{ +} + +void System_CPU2_WaitReady(void) +{ +} + +void System_DSP_Start(void) +{ +} + +void System_DSP_WaitReady(void) +{ +} + +void System_OnStrg_DownloadFW(void) +{ +#if defined(_FW_TYPE_PARTIAL_) || defined(_FW_TYPE_PARTIAL_COMPRESS_) + SHMINFO *p_shm; + unsigned char *p_fdt = (unsigned char *)fdt_get_base(); + + if (p_fdt == NULL) { + DBG_ERR("p_fdt is NULL.\n"); + return; + } + + int len; + int nodeoffset; + const void *nodep; /* property node pointer */ + + // read SHMEM_PATH + nodeoffset = fdt_path_offset(p_fdt, SHMEM_PATH); + if (nodeoffset < 0) { + DBG_ERR("failed to offset for %s = %d \n", SHMEM_PATH, nodeoffset); + } else { + DBG_DUMP("offset for %s = %d \n", SHMEM_PATH, nodeoffset); + } + nodep = fdt_getprop(p_fdt, nodeoffset, "reg", &len); + if (len == 0 || nodep == NULL) { + DBG_ERR("failed to access reg.\n"); + return; + } else { + unsigned int *p_data = (unsigned int *)nodep; + p_shm = (SHMINFO *)be32_to_cpu(p_data[0]); + DBG_DUMP("p_shm = 0x%08X\n", (int)p_shm); + } + + if ((p_shm->boot.LdCtrl2 & LDCF_BOOT_CARD) == 0) { + FWSRV_CMD Cmd = {0}; + FWSRV_PL_LOAD_BURST_IN pl_in = {0}; + + // start partial load + void (*LoadCallback)(const UINT32 Idx) = UserSection_LoadCb; + UINT32 *SecOrderTable = UserSection_Order_full; + + LoadCallback(CODE_SECTION_01); // 1st part has loaded by loader + + ER er; + pl_in.puiIdxSequence = SecOrderTable; + pl_in.fpLoadedCb = LoadCallback; + Cmd.Idx = FWSRV_CMD_IDX_PL_LOAD_BURST; //continue load + Cmd.In.pData = &pl_in; + Cmd.In.uiNumByte = sizeof(pl_in); + Cmd.Prop.bExitCmdFinish = TRUE; + + er = FwSrv_Cmd(&Cmd); + if (er != FWSRV_ER_OK) { + DBG_ERR("Process failed!\r\n"); + return; + } + } +#endif + return; +} +#endif + +#if (IPCAM_FUNC != ENABLE) + +#include "SysFW_Upgrade.h" + +UINT32 System_OnStrg_UploadFW(UINT32 DevID) +{ + INT32 fst_er; +// ER fws_er; + unsigned char *p_Mem = NULL; + FST_FILE hFile = NULL; + UINT32 uiFwSize = 0; + DBG_FUNC_BEGIN("\r\n"); + + //m_bUpdRename = FALSE; + + uiFwSize = FileSys_GetFileLen(FW_UPDATE_NAME); + uiFwSize += _EMBMEM_BLK_SIZE_; /* IMPOARTANT!! */ + + hFile = FileSys_OpenFile(FW_UPDATE_NAME, FST_OPEN_READ); + + if (hFile == 0) { + DBG_ERR("cannot find %s\r\n", FW_UPDATE_NAME); + return UPDNAND_STS_FW_INVALID_STG; + } + + + + p_Mem = (unsigned char *)SxCmd_GetTempMem(uiFwSize); + if(NULL == p_Mem){ + DBG_ERR("Alloc Temp Mem is NULL(uiFwSize=%d)\r\n",uiFwSize); + return UPDNAND_STS_FW_READ2_ERR; + } + + fst_er = FileSys_ReadFile(hFile, (UINT8 *)p_Mem, &uiFwSize, 0, NULL); + DBG_IND("Update Filename=%s, File Size=%d\r\n",FW_UPDATE_NAME,uiFwSize); + FileSys_CloseFile(hFile); + if (fst_er != FST_STA_OK) { + DBG_ERR("FW bin read fail\r\n"); + return UPDNAND_STS_FW_READ_ERR; + } + + DBG_DUMP("p_Mem = %lx size = %lx\n", (UINT32)p_Mem, (UINT32)uiFwSize); + + SysFW_Upgrade_Init(); + SysFW_Upgrade((UINT32)p_Mem, (UINT32)uiFwSize); + +// FWSRV_BIN_UPDATE_ALL_IN_ONE Desc = {0}; +// Desc.uiSrcBufAddr = (UINT32)p_Mem; +// Desc.uiSrcBufSize = (UINT32)uiFwSize; +// Desc.fpCheckSumCb = CheckSumOKCb; //we rename bin after check sum OK +// +// FWSRV_CMD Cmd = {0}; +// Cmd.Idx = FWSRV_CMD_IDX_BIN_UPDATE_ALL_IN_ONE; //continue load +// Cmd.In.pData = &Desc; +// Cmd.In.uiNumByte = sizeof(Desc); +// Cmd.Prop.bExitCmdFinish = TRUE; +// +// fws_er = FwSrv_Cmd(&Cmd); + + + SxCmd_RelTempMem((UINT32)p_Mem); + + /* + if(fws_er == FWSRV_ER_INVALID_UPDATED_DATA || fws_er == FWSRV_ER_WRITE_BLOCK) + { + DBG_ERR("update failed, start to use loader update mechanism.\r\n"); + //GxSystem_EnableHWReset(0); + //GxSystem_PowerOff(); + return UPDNAND_STS_FW_WRITE_CHK_ERR; + } + else if(fws_er != FWSRV_ER_OK) + { + DBG_ERR("FW bin check failed %d\r\n",fws_er); + if(m_bUpdRename) + { + if(FileSys_RenameFile(&uiUpdateFWName[3],LOADER_UPD_FW_PATH, TRUE)==FST_STA_OK) //[3]: remove "A:\\" + { + FileSys_DeleteFile(FW_DEL_INDIACTION_PATH); + } + } + return UPDNAND_STS_FW_READ_CHK_ERR; + } + */ + DBG_FUNC_END("\r\n"); + return UPDNAND_STS_FW_OK; +} +#endif + +#if (LOGFILE_FUNC==ENABLE) +void System_DetErr(void) +{ + #if 0 //LOGFILE_FUNC TODO + extern void LogFile_DumpMemAndSwReset(void); + + #if (LOGFILE_FUNC==ENABLE) + if (LogFile_ChkSysErr() != E_OK) { + LogFile_DumpMemAndSwReset(); + } + #endif + #endif //LOGFILE_FUNC TODO +} +#endif + +/////////////////////////////////////////////////////////////////////////////// diff --git a/code/application/source/cardv/SrcCode/UIApp/Background/UIBackgroundObj.c b/code/application/source/cardv/SrcCode/UIApp/Background/UIBackgroundObj.c index 5bc501f51..ec905f8a1 100755 --- a/code/application/source/cardv/SrcCode/UIApp/Background/UIBackgroundObj.c +++ b/code/application/source/cardv/SrcCode/UIApp/Background/UIBackgroundObj.c @@ -26,6 +26,7 @@ #include "UIApp/Network/EthCamAppCmd.h" #if (USE_DCF == ENABLE) #include "DCF.h" + #endif #include "Utility/SwTimer.h" @@ -861,9 +862,103 @@ UINT32 BackgroundFormat(void) UINT32 BackgroundFormatEmmc(void) { - printf(" BackgroundFormatEmmc\n "); - return TRUE; + int ret; + DBG_FUNC_BEGIN("\r\n"); +#if HUNTING_CAMERA_MCU == ENABLE + sf_sys_status_led_set(SF_LED_SYS_STATE_SD_FORMAT_START); + //sf_sys_status_led_set(SF_LED_SYS_STATE_EXIT_GO_TO_PIR); +#endif + //DX_HANDLE pStrgDev = Dx_GetObject(DX_CLASS_STORAGE_EXT|DX_TYPE_CARD1); + //UINT32 hStrgObj = Dx_Getcaps(pStrgDev, STORAGE_CAPS_HANDLE, 0); + //ret = FileSys_FormatDisk((HNVT_STRG)hStrgObj, FALSE); + FS_HANDLE pStrgDXH = (FS_HANDLE)Dx_GetObject(DX_CLASS_STORAGE_EXT | DX_TYPE_CARD1); + //FS_HANDLE pStrgDXH = (FS_HANDLE)sdio_getStorageObject(STRG_OBJ_FAT1); + DBG_FUNC("pStrgDXH=0x%08X\r\n",pStrgDXH); + //#NT#2016/05/30#Lincy Lin -begin + //#NT#Support logfile function +#if (LOGFILE_FUNC==ENABLE) +#if HUNTING_CAMERA_MCU == ENABLE + UIMenuStoreInfo *puiPara = sf_ui_para_get(); + if (puiPara->DebugMode) + { + LogFile_Suspend(); + LogFile_Complete(); + } +#else + LogFile_Suspend(); + LogFile_Complete(); +#endif + + +#endif + //#NT#2016/05/30#Lincy Lin -end + ret = FileSys_FormatAndLabel('B', pStrgDXH, FALSE, NULL); + DBG_FUNC("Call FileSys_FormatDisk() ret=%d\r\n", ret); + + if (ret == FST_STA_OK) { + // reset file ID (for FileDB) +#if USE_FILEDB + if (UI_GetData(FL_IsUseFileDB)) { + Ux_SendEvent(&UISetupObjCtrl, NVTEVT_FILEID_RESET, 0); + } +#endif +#if (USE_DCF == ENABLE) + //reset next id 100 , 1 + DCF_SetNextID(MIN_DCF_DIR_NUM, MIN_DCF_FILE_NUM); + UI_SetData(FL_DCF_DIR_ID, MIN_DCF_DIR_NUM); + UI_SetData(FL_DCF_FILE_ID, MIN_DCF_FILE_NUM); + UI_SetData(FL_IsDCIMReadOnly, FALSE); +#endif +#if (PLAY_MODE==ENABLE) + if (System_GetState(SYS_STATE_CURRMODE) == PRIMARY_MODE_PLAYBACK) { + UIPlay_PlaySingle(PB_SINGLE_CURR); + } +#endif + //#NT#2016/05/30#Lincy Lin -begin + //#NT#Support logfile function +#if (LOGFILE_FUNC==ENABLE) + #if HUNTING_CAMERA_MCU == ENABLE + if (puiPara->DebugMode) + { + LogFile_ReOpen(); + } + #else + LogFile_ReOpen(); + #endif + +#endif + //#NT#2016/05/30#Lincy Lin -end + // vos_util_delay_ms(1000); + SysMain_system("sync"); + #if HUNTING_CAMERA_MCU == ENABLE + //vos_util_delay_ms(1000); + // sf_sys_status_led_set(SF_LED_SYS_STATE_SD_FORMAT_SUCCESS); + // if(sf_get_pir_statu_flag()){ + // vos_util_delay_ms(3000); + // } + #endif + } + else + { + #if HUNTING_CAMERA_MCU == ENABLE + // sf_sys_status_led_set(SF_LED_SYS_STATE_SD_FORMAT_FAIL); + // if(sf_get_pir_statu_flag()){ + // vos_util_delay_ms(3000); + // } + #endif + } + MovieExe_ResetFileSN(); +#if HUNTING_CAMERA_MCU == ENABLE + // sf_sys_status_led_set(SF_LED_SYS_STATE_SD_FORMAT_EXIT); + // if(sf_get_pir_statu_flag()){ + // vos_util_delay_ms(1000); + // } + sf_set_card_statu(ret); +#endif + DBG_FUNC_END("\r\n"); + return (UINT32)ret; } + UINT32 BackgroundFormatCard(void) { int ret; diff --git a/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c b/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c index 2cca748b6..44e80ff37 100755 --- a/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c +++ b/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c @@ -39,6 +39,8 @@ #if (USE_DCF == ENABLE) #include "DCF.h" #endif +#include "SF_SysStrgMng.h" + #define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER @@ -690,7 +692,7 @@ UINT32 PhotoExe_GetExpectSize_RhoBRCrtl(UINT32 ImgIdx, BOOL bPrimaryOnly) UINT32 PhotoExe_GetFreePicNum(void) { - UINT64 uiFreeSpace; + UINT64 uiFreeSpace = 0; UINT32 uiMaxImageSize; UINT32 freeImgNum; // UINT32 reserveSize = 0x80000; // 500KB @@ -698,10 +700,24 @@ UINT32 PhotoExe_GetFreePicNum(void) UINT32 CaptureSize; UINT32 size; + SF_ST_MMC_DEV *mmc_dev = SF_StrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } + #if (FILESIZE_ALIGN_FUNC) reserveSize += FS_ALIGN_RESERVED_SIZE; #endif - uiFreeSpace = FileSys_GetDiskInfo(FST_INFO_FREE_SPACE); + if(mmc_dev->dev_type == MMC_DEV_SD) + { + uiFreeSpace = FileSys_GetDiskInfoEx('A', FST_INFO_FREE_SPACE); + } + else if(mmc_dev->dev_type == MMC_DEV_EMMC) + { + uiFreeSpace = FileSys_GetDiskInfoEx('B', FST_INFO_FREE_SPACE); + } //DBG_IND("[cap]Free Space = %d KB\r\n", uiFreeSpace / 1024); diff --git a/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c b/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c index 23a4c9ceb..96ce8437d 100755 --- a/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c +++ b/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c @@ -37,6 +37,8 @@ #define __DBGLVL__ 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER #define __DBGFLT__ "*" //*=All, [mark]=CustomClass #include +#include "SF_SysStrgMng.h" + void UIStorageCheck_AllSize(UINT64 *uiTotal, UINT64 *uiRemain) { @@ -56,6 +58,12 @@ void UIStorageCheck_ResetFileReachMax(void) //#NT#Add check for folder attribute static BOOL check_CurrDir_writable(void) { + SF_ST_MMC_DEV *mmc_dev = SF_StrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } UINT32 useFileDB = 0; useFileDB = UI_GetData(FL_IsUseFileDB); @@ -66,9 +74,9 @@ static BOOL check_CurrDir_writable(void) UINT32 CurrDirID; SDCFDIRINFO dirinfo = {0}; - CurrDirID = DCF_GetDBInfo(DCF_INFO_CUR_DIR_ID); + CurrDirID = DCF_GetDBInfoEx(mmc_dev->dcf_handle, DCF_INFO_CUR_DIR_ID); if (CurrDirID) { - if (DCF_GetDirInfo(CurrDirID, &dirinfo)) { + if (DCF_GetDirInfoEx(mmc_dev->dcf_handle, CurrDirID, &dirinfo)) { if (M_IsReadOnly(dirinfo.ucAttrib)) { DBG_IND("DCF folder %d is READONLY.\r\n", CurrDirID); return FALSE; @@ -90,18 +98,32 @@ static BOOL check_CurrDir_writable(void) BOOL UIStorageCheck_DCIMWritable(void) { + SF_ST_MMC_DEV *mmc_dev = SF_StrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } + UINT32 useFileDB = 0; useFileDB = UI_GetData(FL_IsUseFileDB); if (useFileDB) { return TRUE; } else { - char DCIM_DIR[9] = "A:\\DCIM"; + INT32 uiStatus = 0; UINT8 ucAttrib = 0; BOOL ret = FALSE; - - uiStatus = FileSys_GetAttrib(DCIM_DIR, &ucAttrib); + if(mmc_dev->dev_type == MMC_DEV_SD) + { + uiStatus = FileSys_GetAttrib("A:\\DCIM", &ucAttrib); + } + else + { + uiStatus = FileSys_GetAttrib("B:\\DCIM", &ucAttrib); + } + if (uiStatus == FST_STA_OK) { if (ucAttrib & FS_ATTRIB_DIRECTORY) { if (System_GetState(SYS_STATE_CARD) == CARD_REMOVED) { @@ -127,11 +149,90 @@ BOOL UIStorageCheck_DCIMWritable(void) } } -BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) +static BOOL UIStrgCheckFolderFull(DCF_HANDLE DcfHandle) +{ +#if (USE_DCF == ENABLE) + BOOL bIsFileReachMax = FALSE; + UINT32 DCF_DirId = 0, DCF_FileId = 0; + BOOL ret; + + if (System_GetState(SYS_STATE_FS) == FS_NUM_FULL) { + DBG_ERR("UI_Validate_Storage: DIR:999 is existing!\r\n"); + return TRUE; + } + bIsFileReachMax = FALSE; + + ret = DCF_GetNextIDEx(DcfHandle, &DCF_DirId, &DCF_FileId); + if (ret && DCF_DirId == 0 && DCF_FileId == 0) { + bIsFileReachMax = TRUE; + DBG_IND("Next dir_id =%d, file_id = %d \r\n", DCF_DirId, DCF_FileId); + } else if (ret && DCF_GetDBInfoEx(DcfHandle, DCF_INFO_IS_9999) == TRUE) + { + bIsFileReachMax = TRUE; + } + return bIsFileReachMax; +#else + return FALSE; +#endif +} + +static BOOL UIStrgCheckFull(UINT32 *pFreeCount) { #if (PHOTO_MODE==ENABLE) UINT32 uiCountTmp = 0; #endif +#if (PHOTO_MODE==ENABLE) + uiCountTmp = PhotoExe_GetFreePicNum(); + DBG_IND("uiCountTmp = %d, pFreeCount=%d\r\n",uiCountTmp,pFreeCount); + if (pFreeCount) { + *pFreeCount = uiCountTmp; + } + if (uiCountTmp == 0) { + return TRUE; + } else { + return FALSE; + } +#else + return FALSE; +#endif +} + +static BOOL UIStrgCheckErr(MMC_DEV_TYPE dev_id) +{ + if(dev_id == MMC_DEV_SD) + { + FileSys_WaitFinishEx('A'); + } + else if(dev_id == MMC_DEV_EMMC) + { + FileSys_WaitFinishEx('B'); + } + + if (System_GetState(SYS_STATE_FS) == FS_DISK_ERROR + || System_GetState(SYS_STATE_FS) == FS_UNKNOWN_FORMAT + || System_GetState(SYS_STATE_FS) == FS_UNFORMATTED + //#NT#2016/12/06#Niven Cho -begin + //#NT#MULTI_DRIVE + || System_GetState(SYS_STATE_CARD) == CARD_REMOVED) + //#NT#2016/12/06#Niven Cho -end + //|| UIStorageCheck_Error() ) + { + DBG_ERR("UIStorageCheck: %d Card Error\r\n", System_GetState(SYS_STATE_FS)); + return TRUE; + } else { + return FALSE; + } +} + +BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) +{ + SF_ST_MMC_DEV *mmc_dev = SF_StrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } + UINT32 useFileDB = 0; useFileDB = UI_GetData(FL_IsUseFileDB); @@ -142,49 +243,11 @@ BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) if (useFileDB) { return FALSE; } else { -#if (USE_DCF == ENABLE) - BOOL bIsFileReachMax = FALSE; - UINT32 DCF_DirId = 0, DCF_FileId = 0; - BOOL ret; - - if (System_GetState(SYS_STATE_FS) == FS_NUM_FULL) { - DBG_ERR("UI_Validate_Storage: DIR:999 is existing!\r\n"); - return TRUE; - } - bIsFileReachMax = FALSE; - //#NT#2011/03/28#Lincy Lin -begin - //#NT#fix delete the 9999th file in 999 folder cause capture not save - ret = DCF_GetNextID(&DCF_DirId, &DCF_FileId); - if (ret && DCF_DirId == 0 && DCF_FileId == 0) { - bIsFileReachMax = TRUE; - DBG_IND("Next dir_id =%d, file_id = %d \r\n", DCF_DirId, DCF_FileId); - } else if (ret && DCF_GetDBInfo(DCF_INFO_IS_9999) == TRUE) - //#NT#2011/03/28#Lincy Lin -end - { - bIsFileReachMax = TRUE; - } - return bIsFileReachMax; -#else - return FALSE; -#endif + UIStrgCheckFolderFull(mmc_dev->dcf_handle); } break; case STORAGE_CHECK_FULL: -#if (PHOTO_MODE==ENABLE) - uiCountTmp = PhotoExe_GetFreePicNum(); - DBG_IND("uiCountTmp = %d, pFreeCount=%d\r\n",uiCountTmp,pFreeCount); - if (pFreeCount) { - *pFreeCount = uiCountTmp; - } - if (uiCountTmp == 0) { - return TRUE; - } else { - return FALSE; - } -#else - return FALSE; -#endif - + UIStrgCheckFull(pFreeCount); break; case STORAGE_CHECK_LOCKED: if (System_GetState(SYS_STATE_CARD) == CARD_LOCKED) { @@ -195,21 +258,7 @@ BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) } break; case STORAGE_CHECK_ERROR: - FileSys_WaitFinish(); - if (System_GetState(SYS_STATE_FS) == FS_DISK_ERROR - || System_GetState(SYS_STATE_FS) == FS_UNKNOWN_FORMAT - || System_GetState(SYS_STATE_FS) == FS_UNFORMATTED - //#NT#2016/12/06#Niven Cho -begin - //#NT#MULTI_DRIVE - || System_GetState(SYS_STATE_CARD) == CARD_REMOVED) - //#NT#2016/12/06#Niven Cho -end - //|| UIStorageCheck_Error() ) - { - DBG_ERR("UIStorageCheck: %d Card Error\r\n", System_GetState(SYS_STATE_FS)); - return TRUE; - } else { - return FALSE; - } + UIStrgCheckErr(mmc_dev->dev_type); break; case STORAGE_CHECK_DCIM_READONLY: if ((UIStorageCheck_DCIMWritable() == FALSE) diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM.rar b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM.rar index 8bebbfc90..3eaa6b61f 100644 Binary files a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM.rar and b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM.rar differ diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMenuCommonConfirm.lvglscr b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMenuCommonConfirm.lvglscr index 22fa20e73..ef0fa19a0 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMenuCommonConfirm.lvglscr +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMenuCommonConfirm.lvglscr @@ -7,7 +7,7 @@ "add buttons": [ ], "animation time": 0, - "button's text": "NO,YES,", + "button's text": "YES,NO,", "class": "lv_msgbox", "click": true, "content": "", diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMovie.lvglscr b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMovie.lvglscr index 9aae795c2..180acfda7 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMovie.lvglscr +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL.UIFlowMovie.lvglscr @@ -1833,7 +1833,7 @@ "x": 0, "y": 98 }, - "hidden": false, + "hidden": true, "locked": false, "long mode": "Roll", "name": "label_sim", @@ -1891,7 +1891,7 @@ "x": 0, "y": 119 }, - "hidden": false, + "hidden": true, "locked": false, "long mode": "Roll", "name": "label_line", diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirm.c b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirm.c index 9fb96c418..e55dc2016 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirm.c +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirm.c @@ -222,7 +222,7 @@ lv_obj_t* UIFlowMenuCommonConfirm_create(){ lv_obj_set_drag(message_box_1, false); lv_obj_set_pos(message_box_1, 55, 53); lv_obj_set_size(message_box_1, 210, 157); - static const char* message_box_1_LVGLPropertyMsgBoxBtnmatrixButtonsText[] = {"NO","YES","",""}; + static const char* message_box_1_LVGLPropertyMsgBoxBtnmatrixButtonsText[] = {"YES","NO","",""}; lv_msgbox_add_btns(message_box_1, message_box_1_LVGLPropertyMsgBoxBtnmatrixButtonsText); lv_plugin_msgbox_allocate_ext_attr(message_box_1); lv_plugin_msgbox_set_font_type(message_box_1, LV_PLUGIN_LANGUAGE_FONT_TYPE_0, LV_MSGBOX_PART_BG); diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirmEventCallback.c b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirmEventCallback.c index 7628eb348..05f41773c 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirmEventCallback.c +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMenuCommonConfirm/UIFlowMenuCommonConfirmEventCallback.c @@ -390,6 +390,7 @@ void UIFlowMenuCommonConfirm_OnOpen(lv_obj_t* obj) set_indev_keypad_group(msgbox); + lv_group_send_data(gp, LV_KEY_RIGHT); } @@ -473,7 +474,7 @@ static void UIFlowMenuCommonConfirm_MessageBox_ValueChanged(lv_obj_t* obj, uint3 { if(NULL == value) return; - if (*value == 1) { + if (*value == 0) { // const char* msgbox_text = lv_msgbox_get_text(obj); const char* msgbox_text = lv_label_get_text(Confirm_label); diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMovie/UIFlowMovie.c b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMovie/UIFlowMovie.c index 6420fd164..0ed342f9f 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMovie/UIFlowMovie.c +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowMovie/UIFlowMovie.c @@ -1816,7 +1816,7 @@ lv_obj_t* UIFlowMovie_create(){ STYLE_COLOR_PROP(0xd3, 0x3c, 0x3c, 0x3c) ; lv_style_set_text_sel_color(&label_sim_s0, LV_STATE_DISABLED, color); STYLE_COLOR_PROP(0x3a, 0x00, 0xb4, 0x95) ; lv_style_set_text_sel_bg_color(&label_sim_s0, LV_STATE_DISABLED, color); lv_obj_t *label_sim = lv_label_create(parent, NULL); - lv_obj_set_hidden(label_sim, false); + lv_obj_set_hidden(label_sim, true); lv_obj_set_click(label_sim, false); lv_obj_set_drag(label_sim, false); lv_plugin_label_allocate_ext_attr(label_sim); @@ -1880,7 +1880,7 @@ lv_obj_t* UIFlowMovie_create(){ STYLE_COLOR_PROP(0xd3, 0x3c, 0x3c, 0x3c) ; lv_style_set_text_sel_color(&label_line_s0, LV_STATE_DISABLED, color); STYLE_COLOR_PROP(0x3a, 0x00, 0xb4, 0x95) ; lv_style_set_text_sel_bg_color(&label_line_s0, LV_STATE_DISABLED, color); lv_obj_t *label_line = lv_label_create(parent, NULL); - lv_obj_set_hidden(label_line, false); + lv_obj_set_hidden(label_line, true); lv_obj_set_click(label_line, false); lv_obj_set_drag(label_line, false); lv_plugin_label_allocate_ext_attr(label_line); diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPhoto/UIFlowPhotoEventCallback.c b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPhoto/UIFlowPhotoEventCallback.c index 82ddeb6f4..2ca389305 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPhoto/UIFlowPhotoEventCallback.c +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPhoto/UIFlowPhotoEventCallback.c @@ -22,6 +22,7 @@ #include "sf_common.h" #if (USE_DCF == ENABLE) #include "DCF.h" +#include "SF_SysStrgMng.h" #endif #if HUNTING_CAMERA_MCU == ENABLE #include @@ -673,6 +674,12 @@ static void update_camera_message(void) UIMenuStoreInfo *puiPara = sf_ui_para_get(); // if((puiPara->CamMode == SF_CAM_MODE_PHOTO) || (puiPara->CamMode == SF_CAM_MODE_PHOTO_VIDEO)) + SF_ST_MMC_DEV *mmc_dev = SF_StrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + } + switch (puiPara->ImgSize) { case PHOTO_SIZE_40M: @@ -719,21 +726,24 @@ static void update_camera_message(void) default: break; } + + #if 1 if (System_GetState(SYS_STATE_FS) == FS_INIT_OK) { UINT32 cardStatus = System_GetState(SYS_STATE_CARD); if (cardStatus != CARD_REMOVED) { - if (g_SysStrg_Chg) - { - static int cnt = 0; - if(cnt++<3){ + //if (g_SysStrg_Chg) + //{ + //static int cnt = 0; + //if(cnt++<3){ // lv_label_set_text(label_6_scr_uiflowphoto, "wait"); - }else{ - g_SysStrg_Chg = false; - cnt = 0; - } - } else if (UIStorageCheck(STORAGE_CHECK_ERROR, NULL) == TRUE) + //}else{ + //g_SysStrg_Chg = false; + //cnt = 0; + //} + //} else + if (UIStorageCheck(STORAGE_CHECK_ERROR, NULL) == TRUE) { // lv_label_set_text(label_6_scr_uiflowphoto, "SD CARD ERROR"); } else if (UIStorageCheck(STORAGE_CHECK_FULL, NULL) == TRUE) @@ -771,6 +781,8 @@ static void update_camera_message(void) set_warning_label_text(label_6_scr_uiflowphoto); lv_label_set_text(label_6_scr_uiflowphoto, "No SD Card"); } + #endif + } extern int is_menu_screen_luck(void); @@ -1851,6 +1863,16 @@ static void UIFlowPhoto_NVTMSG(lv_obj_t* obj, const LV_USER_EVENT_NVTMSG_DATA* m sf_show_send_text(obj, msg->paramArray[0]); break; } + case NVTEVT_STRG_ATTACH: + { + g_SysStrg_Chg = false; + UIStorageCheck(STORAGE_CHECK_FULL, &g_uiFreePicNum); + printf("[*x]===================================================================================\n"); + DBG_DUMP("UI_StorageCheck: g_uiFreePicNum = 0x%ld\r\n", g_uiFreePicNum); + lv_label_set_text(label_6_scr_uiflowphoto, Get_FreePicNumString(g_uiFreePicNum)); + break; + } + default: break; diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPlay/UIFlowPlayEventCallback.c b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPlay/UIFlowPlayEventCallback.c index d1b0a01c1..ce490e6b4 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPlay/UIFlowPlayEventCallback.c +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowPlay/UIFlowPlayEventCallback.c @@ -542,7 +542,7 @@ static void UIFlowPlay_UpdatePlaytime(BOOL bShow) { UINT32 rec_sec = FlowPB_GetMovPlayTime(); lv_slider_set_value(slider_1_scr_uiflowplay, (rec_sec % 3600) % 60 + 1, LV_ANIM_OFF); - lv_label_set_text_fmt(label_playtime_scr_uiflowplay, "%02d:%02d", (rec_sec % 3600) / 60, (rec_sec % 3600) % 60); + lv_label_set_text_fmt(label_playtime_scr_uiflowplay, "%02d:%02d", (rec_sec % 3600) / 60, (rec_sec % 3600) % 60 + 1); } } static void UIFlowPlay_UpdataBtnContainer(BOOL bShow) @@ -1223,7 +1223,7 @@ static void play_video(lv_obj_t *obj) printf("now play the video.\n"); lv_plugin_img_set_src(image_play_scr_uiflowplay, LV_PLUGIN_IMG_ID_SF_PLAY); UINT32 u32CurrPbStatus = 0; - + FlowPB_SetMovPlayTime(0); PB_GetParam(PBPRMID_PLAYBACK_STATUS, &u32CurrPbStatus); if (u32CurrPbStatus != PB_STA_DONE) { @@ -1270,7 +1270,7 @@ static void play_video(lv_obj_t *obj) } if(PLB_ST_PLAY_MOV == g_PlbData.State) { - printf("now stop play the video.\n"); + printf("now move play\n"); // g_PlbData.State = PLB_ST_FULL; // lv_plugin_img_set_src(image_play_scr_uiflowplay, LV_PLUGIN_IMG_ID_SF_STOP); // lv_label_set_text_fmt(label_playtime_scr_uiflowplay, "%02d:%02d", 0, 0); @@ -2026,6 +2026,7 @@ static void UIFlowPlay_Key(lv_obj_t* obj, uint32_t key) { UINT32 uiFileSeq; PB_GetParam(PBPRMID_CURR_FILESEQ, &uiFileSeq); + //FlowPB_SetMovPlayTime(0); if (0 != uiFileSeq) { stop_play(); @@ -2037,6 +2038,7 @@ static void UIFlowPlay_Key(lv_obj_t* obj, uint32_t key) { UINT32 uiFileSeq; PB_GetParam(PBPRMID_CURR_FILESEQ, &uiFileSeq); + //FlowPB_SetMovPlayTime(0); if (0 != uiFileSeq) { stop_play(); diff --git a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowWrnMsg/UIFlowWrnMsgEventCallback.c b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowWrnMsg/UIFlowWrnMsgEventCallback.c index 3658f7e9c..ab157e9bc 100755 --- a/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowWrnMsg/UIFlowWrnMsgEventCallback.c +++ b/code/application/source/cardv/SrcCode/UIWnd/LVGL_SPORTCAM/UIFlowLVGL/UIFlowWrnMsg/UIFlowWrnMsgEventCallback.c @@ -327,15 +327,16 @@ void message_box_wrnmsg_OnKey(lv_obj_t* msgbox, uint32_t key) { case LV_USER_KEY_MENU: // message_box_wrnmsg_OnKeyMenu(msgbox); + break; + //#NT#2023/11/14#Eric - begin + //#NT#Support IVOT_N12144_CO-148_A + case LV_KEY_ENTER: + // UIFlowWrnMsg_CloseScr(NVTEVT_NULL); if(evt != NVTEVT_NULL){ UIFlowWrnMsg_CloseScr(evt); }else{ UIFlowWrnMsg_CloseScr(NVTEVT_NULL); } - //#NT#2023/11/14#Eric - begin - //#NT#Support IVOT_N12144_CO-148_A - case LV_KEY_ENTER: - // UIFlowWrnMsg_CloseScr(NVTEVT_NULL); break; //#NT#2023/11/14#Eric - end default: diff --git a/code/application/source/sf_app/code/source/app/sf_common.c b/code/application/source/sf_app/code/source/app/sf_common.c index 5ac84f093..fd8048023 100755 --- a/code/application/source/sf_app/code/source/app/sf_common.c +++ b/code/application/source/sf_app/code/source/app/sf_common.c @@ -595,7 +595,8 @@ static SINT32 sf_app_process_cmd_SD(SF_MESSAGE_BUF_S *pMessageBuf) UINT32 status; SINT16 startup = sf_poweron_type_get(); - MLOGD("[%d,%s]\n",pMessageBuf->arg1,app_process_SD_getstatusstring(pMessageBuf->arg1)); + MLOGD("[dev_id:%d,evt:%s]\n",pMessageBuf->arg2,app_process_SD_getstatusstring(pMessageBuf->arg1)); + switch(pMessageBuf->arg1) { case CMD_SD_STRG_CB_UNKNOWN: diff --git a/code/lib/include/FileSysTsk.h b/code/lib/include/FileSysTsk.h index 777487a35..2a7c7a800 100644 --- a/code/lib/include/FileSysTsk.h +++ b/code/lib/include/FileSysTsk.h @@ -1715,6 +1715,7 @@ extern int FileSys_SearchFileRewind(FS_SEARCH_HDL pSearch); #define FileSys_RegisterCB(parm1) FileSys_RegisterCBEx('A', parm1) #define FileSys_Benchmark(parm1,parm2,parm3) FileSys_BenchmarkEx('A', parm1,parm2,parm3) + #define fs_getcwd FileSys_GetCwd #define fs_setcwd FileSys_SetCwd #define fs_dir_getParent FileSys_GetParentDir diff --git a/code/lib/source/sifar/code/source/common/sf_sd_common.c b/code/lib/source/sifar/code/source/common/sf_sd_common.c index 981b5d3e1..39a4ae4c9 100644 --- a/code/lib/source/sifar/code/source/common/sf_sd_common.c +++ b/code/lib/source/sifar/code/source/common/sf_sd_common.c @@ -43,6 +43,7 @@ #include #include "UIInfo/UIInfo.h" #include +#include "sf_sd_common.h" SF_CALLBACK_SD_CMD g_fpSd_Exist_CB = NULL; static int formatSD = CMD_FORMAT_SD_ERR; diff --git a/rtos/code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h b/rtos/code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h index 5e4084828..1b64780ba 100755 --- a/rtos/code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h +++ b/rtos/code/application/source/cardv/SrcCode/PrjCfg_HUNTING_S550.h @@ -948,8 +948,8 @@ #define SF_BASE_VERSION "7MR5RCwDC05" #define DCF_DIR_NAME "MEDIA" /* 100MEDIA */ #define DCF_FILE_NAME "SYGW" /* SYFW0001.JPG */ -#define PHOTO_THUMB_PATH "A:\\THUMB\\" -#define MOVIE_THUMB_PATH "A:\\THUMB\\" +#define PHOTO_THUMB_PATH ":\\THUMB\\" +#define MOVIE_THUMB_PATH ":\\THUMB\\" #define SF_SEND_LIST_DIR "/mnt/sd/THUMB" #define SF_THUMB_SEND_LIST PHOTO_THUMB_PATH"send.list" #define SF_THUMB_SEND_AUTO PHOTO_THUMB_PATH"auto.list" diff --git a/rtos/code/application/source/cardv/SrcCode/System/sys_filesys.c b/rtos/code/application/source/cardv/SrcCode/System/sys_filesys.c index ae1dc14be..6511fedcf 100755 --- a/rtos/code/application/source/cardv/SrcCode/System/sys_filesys.c +++ b/rtos/code/application/source/cardv/SrcCode/System/sys_filesys.c @@ -21,6 +21,7 @@ #if (HUNTING_CAMERA_MODEL == ENABLE) #include "IOCfg.h" +#include "sf_sd_common.h" #define GPIO_CARD_INSERT_LEVEL (FALSE) // low active #define MAX_OPENED_FILE_NUM 10 @@ -105,18 +106,20 @@ static void card_insert_job(void) // call the function to wait init finish FileSys_WaitFinishEx('A'); FileSys_SetParamEx('A', FST_PARM_UPDATE_FSINFO , TRUE); + + SF_RtosStrgRegister(0, ret); #if HUNTING_CAMERA_MCU == ENABLE - if(TRUE == sf_check_card_full()) - { - DBG_WRN("ERR card full\r\n"); - fastboot_set_done(BOOT_INIT_FILESYSOK); - } - else - { + //if(TRUE == sf_check_card_full()) + //{ + //DBG_WRN("ERR card full\r\n"); fastboot_set_done(BOOT_INIT_FILESYSOK); + //} + //else + //{ + // sf_log_confg(); // sf_log_open(); - } + //} #endif #if FS_MULTI_STRG_FUNC @@ -139,6 +142,7 @@ static void card_insert_job(void) } // call the function to wait init finish FileSys_WaitFinishEx('B'); + SF_RtosStrgRegister(1, ret); // FileSys_SetParamEx('B', FST_PARM_UPDATE_FSINFO , TRUE); #endif @@ -159,6 +163,7 @@ static void sys_detect_card_task(void) #if defined(_EMBMEM_EMMC_) THREAD_ENTRY(); + SF_RtosStrgInit(); card_insert_job(); THREAD_RETURN(0); @@ -191,7 +196,7 @@ static void sys_detect_card_task(void) vTaskDelay(pdMS_TO_TICKS(1000)); } - + SF_RtosStrgUnInit(); THREAD_RETURN(0); #endif } diff --git a/rtos/code/application/source/cardv/SrcCode/UIApp/MovieFast/MovieFast.c b/rtos/code/application/source/cardv/SrcCode/UIApp/MovieFast/MovieFast.c index c2079f0a6..d5ca7334d 100644 --- a/rtos/code/application/source/cardv/SrcCode/UIApp/MovieFast/MovieFast.c +++ b/rtos/code/application/source/cardv/SrcCode/UIApp/MovieFast/MovieFast.c @@ -64,6 +64,7 @@ #endif #include "IOCfg.h" #include +#include "sf_sd_common.h" /** Flags for control */ @@ -859,12 +860,20 @@ static void MovieFast_OnRecStop(void) static DCF_HANDLE MovieFast_Get_DCF_Handle(void) { -#if (FS_MULTI_STRG_FUNC) +//#if (FS_MULTI_STRG_FUNC) /* check free space here */ - return g_dcf_hdl2; -#else - return g_dcf_hdl; -#endif + //return g_dcf_hdl2; +//#else + //return g_dcf_hdl; +//#endif + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return -1; + } + DBG_WRN("photofast DCF_GET_HANDLE, %d\n", mmc_dev->dcf_handle); + return mmc_dev->dcf_handle; } static void MovieFast_FileNamingCB(MOVIE_CFG_REC_ID id, char *pFileName) @@ -1118,9 +1127,24 @@ static void MovieFast_UserEventCb(UINT32 id, MOVIE_USER_CB_EVENT event_id, UINT3 char tmp[256] = {'\0'}; - #if HUNTING_CAMERA_MCU == ENABLE - snprintf(tmp, sizeof(tmp), "%s%s", MOVIE_THUMB_PATH, thumb_current_path); /* DCF 8.3 naming rule */ + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + } + else + { + if(mmc_dev->dev_type == MMC_DEV_SD) + { + snprintf(tmp, sizeof(tmp), "%c%s%s", 'A', MOVIE_THUMB_PATH, thumb_current_path); /* DCF 8.3 naming rule */ + } + else + { + snprintf(tmp, sizeof(tmp), "%c%s%s", 'B', MOVIE_THUMB_PATH, thumb_current_path); /* DCF 8.3 naming rule */ + } + } + #else snprintf(tmp, sizeof(tmp), "%s%s", MOVIE_THUMB_PATH, (thumb_current_path + (length - 12))); /* DCF 8.3 naming rule */ snprintf(tmp + strlen(tmp) - 3, sizeof(tmp), "%s", "JPG"); @@ -1233,6 +1257,8 @@ THREAD_RETTYPE MovieFast_InitFileNamingThread(void *arg) } #endif + SF_RtosStrgSetDcfHandle(MMC_DEV_SD, g_dcf_hdl); + SF_RtosStrgSetDcfHandle(MMC_DEV_EMMC, g_dcf_hdl2); #if HUNTING_CAMERA_MCU == ENABLE if(TRUE != sf_is_card_full()) diff --git a/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c b/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c index 323351ecb..329f61430 100644 --- a/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c +++ b/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIAppPhoto_Exe.c @@ -27,6 +27,8 @@ #include "UIApp/AppDisp_PipView.h" #include #include "vendor_videocapture.h" +#include "sf_sd_common.h" + #define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER @@ -615,17 +617,31 @@ UINT32 PhotoExe_GetExpectSize_RhoBRCrtl(UINT32 ImgIdx, BOOL bPrimaryOnly) UINT32 PhotoExe_GetFreePicNum(void) { - UINT64 uiFreeSpace; + UINT64 uiFreeSpace = 0; UINT32 uiMaxImageSize; UINT32 freeImgNum; UINT32 reserveSize = 0x80000; // 500KB UINT32 CaptureSize; UINT32 size; + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } + #if (FILESIZE_ALIGN_FUNC) reserveSize += FS_ALIGN_RESERVED_SIZE; #endif - uiFreeSpace = FileSys_GetDiskInfo(FST_INFO_FREE_SPACE); + if(mmc_dev->dev_type == MMC_DEV_SD) + { + uiFreeSpace = FileSys_GetDiskInfoEx('A', FST_INFO_FREE_SPACE); + } + else if(mmc_dev->dev_type == MMC_DEV_EMMC) + { + uiFreeSpace = FileSys_GetDiskInfoEx('B', FST_INFO_FREE_SPACE); + } DBG_IND("[cap]Free Space = %d KB\r\n", uiFreeSpace / 1024); @@ -659,7 +675,6 @@ UINT32 PhotoExe_GetFreePicNum(void) return freeImgNum; } - void PhotoExe_GetDispCord(URECT *dispCord) { UINT32 ImageRatioIdx = 0; diff --git a/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c b/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c index 23a4c9ceb..65e981cf7 100755 --- a/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c +++ b/rtos/code/application/source/cardv/SrcCode/UIApp/Photo/UIStorageCheck.c @@ -30,6 +30,8 @@ #include "FileSysTsk.h" #include "PlaybackTsk.h" #include "DCF.h" +#include "sf_sd_common.h" + #define THIS_DBGLVL 2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER /////////////////////////////////////////////////////////////////////////////// @@ -46,16 +48,22 @@ void UIStorageCheck_AllSize(UINT64 *uiTotal, UINT64 *uiRemain) (*uiRemain) /= (1024 * 1024); } + static BOOL bIsFileReachMax = FALSE; void UIStorageCheck_ResetFileReachMax(void) { bIsFileReachMax = FALSE; } -//#NT#2009/12/30#Ben Wang -begin -//#NT#Add check for folder attribute + static BOOL check_CurrDir_writable(void) { + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } UINT32 useFileDB = 0; useFileDB = UI_GetData(FL_IsUseFileDB); @@ -66,9 +74,9 @@ static BOOL check_CurrDir_writable(void) UINT32 CurrDirID; SDCFDIRINFO dirinfo = {0}; - CurrDirID = DCF_GetDBInfo(DCF_INFO_CUR_DIR_ID); + CurrDirID = DCF_GetDBInfoEx(mmc_dev->dcf_handle, DCF_INFO_CUR_DIR_ID); if (CurrDirID) { - if (DCF_GetDirInfo(CurrDirID, &dirinfo)) { + if (DCF_GetDirInfoEx(mmc_dev->dcf_handle, CurrDirID, &dirinfo)) { if (M_IsReadOnly(dirinfo.ucAttrib)) { DBG_IND("DCF folder %d is READONLY.\r\n", CurrDirID); return FALSE; @@ -88,20 +96,34 @@ static BOOL check_CurrDir_writable(void) } } + + BOOL UIStorageCheck_DCIMWritable(void) { + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } + UINT32 useFileDB = 0; useFileDB = UI_GetData(FL_IsUseFileDB); if (useFileDB) { return TRUE; - } else { - char DCIM_DIR[9] = "A:\\DCIM"; + } else { INT32 uiStatus = 0; UINT8 ucAttrib = 0; BOOL ret = FALSE; + if(mmc_dev->dev_type == MMC_DEV_SD) + { + uiStatus = FileSys_GetAttrib("A:\\DCIM", &ucAttrib); + } + else + { + uiStatus = FileSys_GetAttrib("B:\\DCIM", &ucAttrib); + } - - uiStatus = FileSys_GetAttrib(DCIM_DIR, &ucAttrib); if (uiStatus == FST_STA_OK) { if (ucAttrib & FS_ATTRIB_DIRECTORY) { if (System_GetState(SYS_STATE_CARD) == CARD_REMOVED) { @@ -127,11 +149,90 @@ BOOL UIStorageCheck_DCIMWritable(void) } } -BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) +static BOOL UIStrgCheckFolderFull(DCF_HANDLE DcfHandle) +{ +#if (USE_DCF == ENABLE) + BOOL bIsFileReachMax = FALSE; + UINT32 DCF_DirId = 0, DCF_FileId = 0; + BOOL ret; + + if (System_GetState(SYS_STATE_FS) == FS_NUM_FULL) { + DBG_ERR("UI_Validate_Storage: DIR:999 is existing!\r\n"); + return TRUE; + } + bIsFileReachMax = FALSE; + + ret = DCF_GetNextIDEx(DcfHandle, &DCF_DirId, &DCF_FileId); + if (ret && DCF_DirId == 0 && DCF_FileId == 0) { + bIsFileReachMax = TRUE; + DBG_IND("Next dir_id =%d, file_id = %d \r\n", DCF_DirId, DCF_FileId); + } else if (ret && DCF_GetDBInfoEx(DcfHandle, DCF_INFO_IS_9999) == TRUE) + { + bIsFileReachMax = TRUE; + } + return bIsFileReachMax; +#else + return FALSE; +#endif +} + +static BOOL UIStrgCheckFull(UINT32 *pFreeCount) { #if (PHOTO_MODE==ENABLE) UINT32 uiCountTmp = 0; #endif +#if (PHOTO_MODE==ENABLE) + uiCountTmp = PhotoExe_GetFreePicNum(); + DBG_IND("uiCountTmp = %d, pFreeCount=%d\r\n",uiCountTmp,pFreeCount); + if (pFreeCount) { + *pFreeCount = uiCountTmp; + } + if (uiCountTmp == 0) { + return TRUE; + } else { + return FALSE; + } +#else + return FALSE; +#endif +} + +static BOOL UIStrgCheckErr(MMC_DEV_TYPE dev_id) +{ + if(dev_id == MMC_DEV_SD) + { + FileSys_WaitFinishEx('A'); + } + else if(dev_id == MMC_DEV_EMMC) + { + FileSys_WaitFinishEx('B'); + } + + if (System_GetState(SYS_STATE_FS) == FS_DISK_ERROR + || System_GetState(SYS_STATE_FS) == FS_UNKNOWN_FORMAT + || System_GetState(SYS_STATE_FS) == FS_UNFORMATTED + //#NT#2016/12/06#Niven Cho -begin + //#NT#MULTI_DRIVE + || System_GetState(SYS_STATE_CARD) == CARD_REMOVED) + //#NT#2016/12/06#Niven Cho -end + //|| UIStorageCheck_Error() ) + { + DBG_ERR("UIStorageCheck: %d Card Error\r\n", System_GetState(SYS_STATE_FS)); + return TRUE; + } else { + return FALSE; + } +} + +BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) +{ + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return FALSE; + } + UINT32 useFileDB = 0; useFileDB = UI_GetData(FL_IsUseFileDB); @@ -142,49 +243,11 @@ BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) if (useFileDB) { return FALSE; } else { -#if (USE_DCF == ENABLE) - BOOL bIsFileReachMax = FALSE; - UINT32 DCF_DirId = 0, DCF_FileId = 0; - BOOL ret; - - if (System_GetState(SYS_STATE_FS) == FS_NUM_FULL) { - DBG_ERR("UI_Validate_Storage: DIR:999 is existing!\r\n"); - return TRUE; - } - bIsFileReachMax = FALSE; - //#NT#2011/03/28#Lincy Lin -begin - //#NT#fix delete the 9999th file in 999 folder cause capture not save - ret = DCF_GetNextID(&DCF_DirId, &DCF_FileId); - if (ret && DCF_DirId == 0 && DCF_FileId == 0) { - bIsFileReachMax = TRUE; - DBG_IND("Next dir_id =%d, file_id = %d \r\n", DCF_DirId, DCF_FileId); - } else if (ret && DCF_GetDBInfo(DCF_INFO_IS_9999) == TRUE) - //#NT#2011/03/28#Lincy Lin -end - { - bIsFileReachMax = TRUE; - } - return bIsFileReachMax; -#else - return FALSE; -#endif + UIStrgCheckFolderFull(mmc_dev->dcf_handle); } break; case STORAGE_CHECK_FULL: -#if (PHOTO_MODE==ENABLE) - uiCountTmp = PhotoExe_GetFreePicNum(); - DBG_IND("uiCountTmp = %d, pFreeCount=%d\r\n",uiCountTmp,pFreeCount); - if (pFreeCount) { - *pFreeCount = uiCountTmp; - } - if (uiCountTmp == 0) { - return TRUE; - } else { - return FALSE; - } -#else - return FALSE; -#endif - + UIStrgCheckFull(pFreeCount); break; case STORAGE_CHECK_LOCKED: if (System_GetState(SYS_STATE_CARD) == CARD_LOCKED) { @@ -195,21 +258,7 @@ BOOL UIStorageCheck(UINT32 uiCheckItem, UINT32 *pFreeCount) } break; case STORAGE_CHECK_ERROR: - FileSys_WaitFinish(); - if (System_GetState(SYS_STATE_FS) == FS_DISK_ERROR - || System_GetState(SYS_STATE_FS) == FS_UNKNOWN_FORMAT - || System_GetState(SYS_STATE_FS) == FS_UNFORMATTED - //#NT#2016/12/06#Niven Cho -begin - //#NT#MULTI_DRIVE - || System_GetState(SYS_STATE_CARD) == CARD_REMOVED) - //#NT#2016/12/06#Niven Cho -end - //|| UIStorageCheck_Error() ) - { - DBG_ERR("UIStorageCheck: %d Card Error\r\n", System_GetState(SYS_STATE_FS)); - return TRUE; - } else { - return FALSE; - } + UIStrgCheckErr(mmc_dev->dev_type); break; case STORAGE_CHECK_DCIM_READONLY: if ((UIStorageCheck_DCIMWritable() == FALSE) diff --git a/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c b/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c index 5484fb608..486d71eeb 100644 --- a/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c +++ b/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFast.c @@ -42,6 +42,8 @@ #include #include "sf_led.h" #endif +#include "sf_sd_common.h" + #if POWERON_FAST_SLICE_ENC == ENABLE #include "PhotoFastSliceEncode.h" @@ -739,9 +741,10 @@ INT32 PhotoFast_FileNaming_Open(void) DBG_ERR("get dcf handle error!\n"); } - DBG_WRN("DCF_ScanObjEx emmc handle=%d\n", g_dcf_hdl2); DCF_ScanObjEx(g_dcf_hdl2); + SF_RtosStrgSetDcfHandle(MMC_DEV_SD, g_dcf_hdl); + SF_RtosStrgSetDcfHandle(MMC_DEV_EMMC, g_dcf_hdl2); } #endif @@ -767,6 +770,8 @@ INT32 PhotoFast_FileNaming_Close(void) DCF_UnInstallID(); } + SF_RtosStrgSetDcfHandle(MMC_DEV_SD, g_dcf_hdl); + SF_RtosStrgSetDcfHandle(MMC_DEV_EMMC, g_dcf_hdl2); return 0; } @@ -883,12 +888,20 @@ void PhotoFast_FileNaming_SetSortBySN(CHAR *pDelimStr, UINT32 nDelimCount, UINT3 DCF_HANDLE PhotoFast_Get_DCF_Handle() { -#if (FS_MULTI_STRG_FUNC) +//#if (FS_MULTI_STRG_FUNC) /* check free space here */ - return g_dcf_hdl2; -#else - return g_dcf_hdl; -#endif + //return g_dcf_hdl2; +//#else + //return g_dcf_hdl; +//#endif + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + return -1; + } + DBG_WRN("photofast DCF_GET_HANDLE, %d\n", mmc_dev->dcf_handle); + return mmc_dev->dcf_handle; } INT32 PhotoFast_WriteFile(UINT32 Addr, UINT32 Size, UINT32 Fmt, UINT32 uiPathId, char* Path) diff --git a/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFastSliceEncode.c b/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFastSliceEncode.c index 7c1cb9984..c9e94f248 100644 --- a/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFastSliceEncode.c +++ b/rtos/code/application/source/cardv/SrcCode/UIApp/PhotoFast/PhotoFastSliceEncode.c @@ -21,6 +21,7 @@ #include "sys_usrmem.h" #if HUNTING_CAMERA_MCU == ENABLE #include +#include "sf_sd_common.h" #endif #define VDO_YUV_BUFSIZE(w, h, pxlfmt) ALIGN_CEIL_4(((w) * (h) * HD_VIDEO_PXLFMT_BPP(pxlfmt)) / 8) @@ -2384,7 +2385,22 @@ INT32 PhotoFast_SliceEncode_CB3(void* user_data) #endif #if HUNTING_CAMERA_MCU == ENABLE - snprintf(tmp, sizeof(tmp), "%s%s", PHOTO_THUMB_PATH, file_path); /* DCF 8.3 naming rule */ + SF_RTOS_ST_MMC_DEV *mmc_dev = SF_RtosStrgCheckWorkableDev(); + if(mmc_dev->dcf_handle < 0) + { + DBG_ERR("No MMC_Dev Can use!\n"); + } + else + { + if(mmc_dev->dev_type == MMC_DEV_SD) + { + snprintf(tmp, sizeof(tmp), "%c%s%s", 'A', PHOTO_THUMB_PATH, file_path); /* DCF 8.3 naming rule */ + } + else + { + snprintf(tmp, sizeof(tmp), "%c%s%s", 'B', PHOTO_THUMB_PATH, file_path); /* DCF 8.3 naming rule */ + } + } #else UINT32 length = strlen(file_path); snprintf(tmp, sizeof(tmp), "%s%s", PHOTO_THUMB_PATH, file_path + length - 12); /* DCF 8.3 naming rule */ diff --git a/rtos/code/driver/na51089/include/sf_sd_common.h b/rtos/code/driver/na51089/include/sf_sd_common.h new file mode 100755 index 000000000..6c6635ab9 --- /dev/null +++ b/rtos/code/driver/na51089/include/sf_sd_common.h @@ -0,0 +1,75 @@ +/************************************************************************** + * + * Copyright (c) 2015-2021 by WuYuan 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.. + * + * WuYuan Technology, Inc. reserves the right to modify this software without notice. + * + * Author: Sober + * Ver: 1.0.0 2023.12.23 + * Description: Creat +**************************************************************************/ +#ifndef _SF_SD_COMM_H_ +#define _SF_SD_COMM_H_ + +#define MMC_DEV_MAX_NUM (2) + +typedef enum +{ + MMC_DEV_SD = 0, + MMC_DEV_EMMC = 1, + MMC_DEV_NO = 2, +}MMC_DEV_TYPE; + +typedef enum +{ + MMC_DEV_NODE_STATE_NO = 0, + MMC_DEV_NODE_STATE_EXIST = 1, + MMC_DEV_NODE_STATE_NO_EXIST = 2, +}MMC_DEV_NODE_STATE; + +typedef enum +{ + MMC_DEV_MOUNT_STATE_NO = 0, + MMC_DEV_MOUNT_STATE_MOUNTED = 1, + MMC_DEV_MOUNT_STATE_UNMOUNTED = 2, +}MMC_DEV_MOUNT_STATE; + +typedef enum +{ + MMC_DEV_SPACE_STATE_NO = 0, + MMC_DEV_SPACE_STATE_ENOUGH = 1, + MMC_DEV_SPACE_STATE_NO_ENOUGH = 2, +}MMC_DEV_SPACE_STATE; + +typedef enum +{ + MMC_DEV_LOOP_STATE_NO = 0, + MMC_DEV_LOOP_STATE_ON = 1, + MMC_DEV_LOOP_STATE_OFF = 2, +}MMC_DEV_LOOP_STATE; + +typedef struct +{ + MMC_DEV_TYPE dev_type; + MMC_DEV_MOUNT_STATE moumted_state; + MMC_DEV_SPACE_STATE space_state; + MMC_DEV_LOOP_STATE loop_state; + int dcf_handle; +}SF_RTOS_ST_MMC_DEV; + +void SF_RtosStrgInit(void); +void SF_RtosStrgUnInit(void); +int SF_RtosStrgRegister(int devid, int mounted_state); +void SF_RtosStrgSetDcfHandle(UINT32 strg_id, UINT32 handle); +SF_RTOS_ST_MMC_DEV *SF_RtosStrgCheckWorkableDev(void); + +#endif \ No newline at end of file diff --git a/rtos/code/driver/na51089/source/mcu/sf_sd_common.c b/rtos/code/driver/na51089/source/mcu/sf_sd_common.c index 1c4df5db2..7fdd216b6 100755 --- a/rtos/code/driver/na51089/source/mcu/sf_sd_common.c +++ b/rtos/code/driver/na51089/source/mcu/sf_sd_common.c @@ -43,16 +43,18 @@ //#include #include "UIInfo/UIInfo.h" #include +#include "sf_sd_common.h" static BOOL IsCardFull = FALSE; SF_CALLBACK_SD_CMD g_fpSd_Exist_CB = NULL; extern BOOL DrvCARD_DetStrgCard(void); +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) @@ -90,6 +92,7 @@ UINT32 sf_check_card_full(void) return ret; } + void sf_sd_exist_reg_cb(SF_CALLBACK_SD_CMD fpCB) { g_fpSd_Exist_CB = fpCB; @@ -110,6 +113,202 @@ BOOL sf_in_card_exist(void) } +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_NO; + //sf_rtos_mmc_dev[i]->node = MMC_DEV_NODE_STATE_NO; + sf_rtos_mmc_dev[i]->moumted_state = MMC_DEV_MOUNT_STATE_NO; + sf_rtos_mmc_dev[i]->space_state = MMC_DEV_SPACE_STATE_NO; + //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 */ + { + ret = 1; + } + else + { + ret = 0; + } + DBG_WRN("[%d]sd card diskFree=%lluM, ret = %d\n", __LINE__, 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; + + UINT32 isfull = 0; + isfull = sf_rtos_mmc_dev_space_check_full(MMC_DEV_SD); + if(isfull == 1) + { + sf_rtos_mmc_dev[MMC_DEV_SD]->space_state = MMC_DEV_SPACE_STATE_NO_ENOUGH; + } + else if(isfull == 0) + { + sf_rtos_mmc_dev[MMC_DEV_SD]->space_state = MMC_DEV_SPACE_STATE_ENOUGH; + } + + isfull = sf_rtos_mmc_dev_space_check_full(MMC_DEV_EMMC); + if(isfull == 1) + { + sf_rtos_mmc_dev[MMC_DEV_EMMC]->space_state = MMC_DEV_SPACE_STATE_NO_ENOUGH; + } + else if(isfull == 0) + { + sf_rtos_mmc_dev[MMC_DEV_EMMC]->space_state = MMC_DEV_SPACE_STATE_ENOUGH; + } + + 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[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + 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[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + 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[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH && + sf_rtos_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + workable_dev = MMC_DEV_EMMC; + } + else if(sf_rtos_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + workable_dev = MMC_DEV_EMMC; + } + else if(sf_rtos_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH) + { + 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, space:%d\n", sf_rtos_mmc_dev[i]->moumted_state, + sf_rtos_mmc_dev[i]->space_state); + } + if(workable_dev == MMC_DEV_NO) + { + return NULL; + } + else + { + return sf_rtos_mmc_dev[workable_dev]; + } + +} + diff --git a/rtos/code/lib/include/FileSysTsk.h b/rtos/code/lib/include/FileSysTsk.h index efaf12657..edab30250 100755 --- a/rtos/code/lib/include/FileSysTsk.h +++ b/rtos/code/lib/include/FileSysTsk.h @@ -1722,5 +1722,9 @@ extern int FileSys_SearchFileRewind(FS_SEARCH_HDL pSearch); #define fs_SearchFile FileSys_SearchFile #define fs_SearchFileClose FileSys_SearchFileClose #define fs_SearchFileRewind FileSys_SearchFileRewind + +#define FileSys_GetEMMCDiskInfo(parm1) FileSys_GetDiskInfoEx('B', parm1) + + //@} #endif