fs.c

Go to the documentation of this file.

/****************** COPYRIGHT (C) 2007-2012 KEOLABS S.A.S. *****************/
/*******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "circle.h"

#if SDCARD_SDIO
#include "sdio_sd.h"
#else
#include "spi_sd.h"
#endif
#include "diskio.h"
#include "fs.h"
#include <string.h>
#include <stdio.h>


/* Private typedef -----------------------------------------------------------*/

/* Private define ------------------------------------------------------------*/
#define MAX_DIRS LIST_MAXITEM
#define MAX_LIST_ITEMS_DISP 7
#define MAX_PATH_LENGTH 200
#if LCD_HIGH_DEF
#define MAXDIRNAMELEN 30
#else
#define MAXDIRNAMELEN 17
#endif
#define BUFSIZE  512            // Size of buffer used for file copy and compare
    
/* Private macro -------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/
static union array
{
    u8 sector[SECTOR_SIZE];    // the char array
    unsigned int  i;           // force 32-bit int alignment
} u;
static u32 StartMBR;
static u8  SDCardfault = 0;

/* Public variables ----------------------------------------------------------*/
// The variables are kept to respect the API of CircleOS
VOLINFO volume_info;
DIRINFO directory_info;
DIRENT directory_entry;
u8* FS_PathFilter = 0;

struct DirItem
{
    u8 Name[MAXDIRNAMELEN];
    u8 flags;
};

struct DirItem DirItems[MAX_DIRS];

//YRT13065tList DirMenu =    {    1,    "SD Card",    30,    20, 0, 0, 0, 0,    6,    0,    0,    };
tList DirMenu =    {    1,    "SD Card",    MAX_DIRS,    MAXDIRNAMELEN, 0, 0, 0, 0,    MAX_LIST_ITEMS_DISP,    0,    0,    };

u8 level = 0;
u8 CurrentPath[MAX_PATH_LENGTH];

// These variables contain all informations about the file system, current directory, ...
FATFS fs;
DIR CurrentDir;
FIL file, file2;
FILINFO fileInfo;


/* External variables ---------------------------------------------------------*/
extern WCHAR LfnBuf[_MAX_LFN + 1];
extern BYTE sfn[12];
extern divider_t Appli_Divider;
extern divider_t Appli_DividerBkp;

/* Private functions ----------------------------------------------------------*/
void NVIC_Config_SDIO( void );




/*******************************************************************************
*
*                            FillVolInfo
*
*******************************************************************************/
/*******************************************************************************/
NODEBUG void FillVolInfo( PVOLINFO volinfo )
{
    volinfo->unit = fs.drv;
    volinfo->filesystem = fs.fs_type;
    //~ volinfo->label = ;
    volinfo->startsector = fs.fatbase;
    volinfo->secperclus = fs.csize;
    //~ volinfo->reservedsecs = ;
    //~ volinfo->numsecs = ;
    volinfo->secperfat = fs.fsize;
    volinfo->rootentries = fs.n_rootdir;
    //~ volinfo->numclusters = ;
    volinfo->fat1 = fs.fatbase;
    volinfo->rootdir = fs.dirbase;
    volinfo->dataarea = fs.database;
}

/*******************************************************************************
*
*                            FillDirInfo
*
*******************************************************************************/
/*******************************************************************************/
NODEBUG void FillDirInfo( PDIRINFO dirinfo, DIR* dir )
{
    dirinfo->currentcluster = dir->clust;
    dirinfo->currentsector = dir->sect;
    dirinfo->currententry = dir->index;
    // dirinfo->scratch = ;     This field is prepopulated in FS_OpenDir for example
    dirinfo->flags = 0; // Picked at the beginning of DFS_OpenDir
}

/*******************************************************************************
*
*                            FillDirEnt
*
*******************************************************************************/
/*******************************************************************************/
NODEBUG void FillDirEnt( PDIRENT dirent )
{
    strncpy( dirent->name, fileInfo.fname, sizeof( dirent->name ) );
    dirent->name[sizeof( dirent->name ) - 1] = '\0';
    dirent->attr = fileInfo.fattrib;
    dirent->reserved = 0;   // Must be 0
}

/*******************************************************************************
*
*                            FillFileInfo
*
*******************************************************************************/
/*******************************************************************************/
NODEBUG void FillFileInfo( PFILEINFO fileinfo )
{
    FillVolInfo( fileinfo->volinfo );
    fileinfo->dirsector = file.dir_sect;
    fileinfo->diroffset = *file.dir_ptr;
    fileinfo->mode = file.flag;
    fileinfo->firstcluster = file.org_clust;
    fileinfo->filelen = file.fsize;
    fileinfo->cluster = file.curr_clust;
    fileinfo->pointer = file.fptr;
}



/* Public functions ----------------------------------------------------------*/

/*******************************************************************************
*
*                            FS_Mount
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Mount( enum STORAGE_device device )
{
#if SDCARD_SDIO
    NVIC_Config_SDIO();
#endif
    //~ return DFS_Mount( device );

    u32 retVal = f_mount( 0, &fs );

    if (retVal == FR_OK)
    {
        // Check if the device is mounted
        const TCHAR* path = "";
        FATFS* tmpFs = &fs;
        retVal = chk_mounted( &path, &tmpFs, 0 );

        // Fill the VOLINFO structure for compatibility
        FillVolInfo( &volume_info );
    }

    return retVal;
}


/*******************************************************************************
*
*                            FS_Unmount
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Unmount( enum STORAGE_device device )
{
    return f_mount( 0, NULL );
}


/*******************************************************************************
*
*                            FS_OpenFile
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_OpenFile( PVOLINFO volinfo, char* path, u8 mode, PFILEINFO fileinfo )
{
    //~ return DFS_OpenFile( volinfo, path, mode, u.sector, fileinfo );

    u32 retVal = DFS_NOPATH;
    fileinfo->volinfo = volinfo;

    if ( path )
    {
        // If the file does not exists, create it (for compatibility)
        if (mode & FS_WRITE)
            mode |= FA_OPEN_ALWAYS;
            
        // Open the file
        retVal = f_open( &file, path, mode );

        // Fill the FILEINFO structure for compatibility
        FillFileInfo( fileinfo );
    }

    return retVal;
}



/*******************************************************************************
*
*                            FS_ReadFile
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_ReadFile( PFILEINFO fileinfo,  u8* buffer, u32* successcount, u32 len )
{
    //~ return DFS_ReadFile( fileinfo, u.sector, buffer, successcount, len );

    u32 retVal = DFS_NULLPOINTER;

    if ( buffer && successcount )
    {
        retVal = f_read( &file, buffer, len, ( int* ) successcount );

        // Fill the FILEINFO structure for compatibility
        FillFileInfo( fileinfo );
    }

    return retVal;
}


/*******************************************************************************
*
*                            FS_WriteFile
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_WriteFile( PFILEINFO fileinfo,  u8* buffer, u32* successcount, u32 len )
{
    //~ return DFS_WriteFile( fileinfo, u.sector, buffer, successcount, len );

    u32 retVal = DFS_NULLPOINTER;
    retVal = f_write( &file, buffer, len, ( int* ) successcount );

    FillFileInfo( fileinfo );

    return retVal;
}


/*******************************************************************************
*
*                            FS_Close
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Close( PFILEINFO fileinfo )
{

    u32 retVal = f_close( &file );

    // Fill the FILEINFO structure for compatibility
    FillFileInfo( fileinfo );

    return retVal;
}




/*******************************************************************************
*
*                            FS_Delete
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Delete( PVOLINFO volinfo, u8* path )
{
    //~ return DFS_UnlinkFile( volinfo, path, u.sector );

    u32 retVal = f_unlink( path );

    // Fill the VOLINFO structure for compatibility
    FillVolInfo( volinfo );

    return retVal;
}


/*******************************************************************************
*
*                            FS_GetNextEntry
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_GetNextEntry( PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent )
{
    //~ return DFS_GetNext( volinfo, dirinfo, dirent );

    u32 retVal = f_readdir( &CurrentDir, &fileInfo );
    if ( fileInfo.fname[0] == 0 )
        retVal = FR_NO_FILE;

    // Fill the DIRENT structure for compatibility
    FillDirEnt( dirent );

    return retVal;
}


/*******************************************************************************
*
*                            FS_OpenDirectory
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_OpenDirectory( PVOLINFO volinfo, u8* dirname, PDIRINFO dirinfo )
{
    //~ dirinfo->scratch = u.sector;  /* DFS Note - you must PREPOPULATE*/
    //~ /* the DIRINFO.scratch field with a pointer to a sector scratch buffer.*/
    //~ return DFS_OpenDir( volinfo, dirname, dirinfo );

    u32 retVal = FR_NO_PATH;
    dirinfo->scratch = u.sector;    // DFS Note - you must PREPOPULATE

    // If there is a trailing slash, remove it
    len_t len = my_strlen( dirname );
    if ( dirname[len - 1] == '/' )
        dirname[len - 1] = 0;

    if ( dirname )
        retVal = f_opendir( &CurrentDir, dirname );

    // Fill the VOLINFO/DIRINFO structure for compatibility
    FillVolInfo( volinfo );
    FillDirInfo( dirinfo, &CurrentDir );
    switch ( retVal )
    {
        case FR_OK: break;
        default:
            break;
    }

    return retVal;
}


/*******************************************************************************
*
*                            FS_GetVolumeInfo
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_GetVolumeInfo( u8 unit, u32 startsector, PVOLINFO volinfo )
{
    //~ return DFS_GetVolInfo( unit, u.sector, startsector, volinfo );

    // Check if the device is mounted
    const TCHAR* path = "";
    FATFS* tmpFs = &fs;
    u32 retVal = chk_mounted( &path, &tmpFs, 0 );

    // Fill the VOLINFO structure for compatibility
    FillVolInfo( volinfo );
    switch ( retVal )
    {
    case FR_OK: break;
    default:
        break;
    }

    return retVal;
}


/*******************************************************************************
*
*                            FS_GetSDCardCurrentPath
*
*******************************************************************************/
u8* FS_GetSDCardCurrentPath( void )
{
    return ( u8* ) &CurrentPath;
}


/*******************************************************************************
*
*                            FS_GetSDCardVolInfo
*
*******************************************************************************/
VOLINFO* FS_GetSDCardVolInfo( void )
{
    return &volume_info;
}

/*******************************************************************************
*
*                            FS_GetPathFilter
*
*******************************************************************************/
u8* FS_GetPathFilter( void )
{
    return FS_PathFilter;
}

/*******************************************************************************
*
*                            FS_SetPathFilter
*
*******************************************************************************/
void FS_SetPathFilter( u8* filter )
{
    if ( filter )
        FS_PathFilter = strupr( filter );
    else
        FS_PathFilter = 0;
}

/*******************************************************************************
*
*                            FS_Seek
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Seek( PFILEINFO fileinfo, u32 offset )
{
    //~ DFS_Seek( fileinfo, offset, u.sector );

    u32 retVal = f_lseek( &file, offset );

    // Fill the FILEINFO structure for compatibility
    FillFileInfo( fileinfo );

    return retVal;
}


/*******************************************************************************
*
*                            FS_Tell
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Tell( PFILEINFO fileinfo )
{
    // Tell from file system
    u32 retVal = f_tell( &file );

    // Fill the FILEINFO structure for compatibility
    FillFileInfo( fileinfo );

    return retVal;
}

/*******************************************************************************
*
*                            FS_Gets
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Gets(char* ptr, int len, PFILEINFO fileinfo)
{
    char* ret_val = f_gets (ptr, len, &file);

    // Fill the FILEINFO structure for compatibility
    FillFileInfo( fileinfo );

    if (!ret_val)
        return FR_DISK_ERR;
    else
        return FR_OK;
}

/*******************************************************************************
*
*                            FS_Size
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Size( PFILEINFO fileinfo )
{
    // Tell from file system
    u32 retVal = f_size( &file );

    // Fill the FILEINFO structure for compatibility
    FillFileInfo( fileinfo );

    return retVal;
}

/*******************************************************************************
*
*                            FS_Eof
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_Eof( PFILEINFO fileinfo )
{
    // Tell from file system
    u32 retVal = f_eof( &file );

    // Fill the FILEINFO structure for compatibility
    FillFileInfo( fileinfo );

    return retVal;
}

/*******************************************************************************
*
*                            FS_FileCopy
*
*******************************************************************************/
/*******************************************************************************/
NODEBUG2 u32 FS_FileCopy( char* dest, char* src )
{
    int total_count_debug ;
    int count, successcount ;
    extern FIL file, file2;
    char buf[BUFSIZE+1];
    int ret = FR_OK;

    total_count_debug = 0;

    // Open the files
    if ( f_open( &file, src, FA_READ ) )
        return FR_NO_FILE;

    if ( f_open( &file2, dest, FA_CREATE_ALWAYS | FA_WRITE ) )
        return FR_NO_FILE;

    // Copy the contents
    while ( 1 )
    {
        if ( !f_read( &file, buf, BUFSIZE, &count ) && count )
        {
            if ( count == 0 )
                break;
            
            if ( !f_write( &file2, buf, count, &successcount ) )
            {
                total_count_debug += successcount;
                continue;
            }
            ret = FR_DISK_ERR;
        }
        f_close( &file2 );
        break;
    }
    f_close( &file );

    return ret;
}

/*******************************************************************************
*
*                            FS_FileCmp
*
*******************************************************************************/
/*******************************************************************************/
u32 FS_FileCmp( char* fn1, char* fn2 )
{
    int total_checked_debug = 0;
    int count1, count2;
    extern FIL file, file2;
    char buf1[BUFSIZE+1];
    char buf2[BUFSIZE+1];
    int ret = FR_OK;

    total_checked_debug = 0;

    if ( f_open( &file, fn2, FA_READ ) )
        return 1;

    if ( f_open( &file2, fn1, FA_READ ) )
        return 1;

    //Copy the contents
    while ( ret == 0 )
    {
        if ( f_read( &file, buf1, BUFSIZE, &count1 ) )
        {
            ret = 1;
            break;
        }
        if ( f_read( &file2, buf2, BUFSIZE, &count2 ) )
        {
            ret = 1;
            break;
        }
        if ( count1 == count2 )
        {
            if ( !count1 )
                break;
            else
            {
                ret = mem_cmp( buf1, buf2, count1 );
                if ( !ret )
                    total_checked_debug += count1;
            }
        }
        else
            ret = 1;
        
        if ( count1 < BUFSIZE )
            break;
    }
    f_close( &file );
    f_close( &file2 );

    return ret;
}

/*******************************************************************************
*
*                            FS_Explorer_UpdateList
*
*******************************************************************************/
NODEBUG void FS_Explorer_UpdateList( void )
{
    u8 i = 0;
    char* fn;

    mem_set( DirItems, 0, sizeof( DirItems ) );

    /* Loop through root dir and display files / dirs*/
    while ( ( f_readdir( &CurrentDir, &fileInfo ) == FR_OK ) && fileInfo.fname[0] )
    {
        // Retrieve the file name
        fn = *fileInfo.lfname ? fileInfo.lfname : fileInfo.fname;

        {
            // Add a link to the parent directory if we are not in the root directory
            if ( ( i == 0 ) && strcmp( CurrentPath, "" ) )
            {
                mem_set( ( void* )DirItems[i].Name, 0, MAXDIRNAMELEN );
                strcat( DirItems[i].Name, "[..]" );
                DirMenu.Items[i].Text = DirItems[i].Name;
                DirItems[i].flags |= FS_ATTR_DIRECTORY; /* set flag in local list*/
                i++;
            }

            /* Directory*/
            if ( fileInfo.fattrib & AM_DIR )
            {
                if ( strncmp( fn, ". ", 2 ) ) /* don't display current "." directory*/
                {
                    strcat( DirItems[i].Name, "[" );
                    strncat( DirItems[i].Name, fn, MAXDIRNAMELEN );
                    strcat( DirItems[i].Name, "]" );

                    DirMenu.Items[i].Text = DirItems[i].Name;
                    DirItems[i].flags |= FS_ATTR_DIRECTORY; /* set flag in local list*/
                    i++;
                }
            }
            else /* File*/
            {
                /* Check if matches the type filter*/
                u8* ext = strrchr( fn, '.' );
                if ( ext )
                    ext++;
                strupr( ext );
                if ( ( FS_PathFilter == 0 ) || ( strncmp( ext, FS_PathFilter, 3 ) == 0 ) )
                {
                    mem_cpy( DirItems[i].Name, fn, MAXDIRNAMELEN - 1 );
                    DirMenu.Items[i].Text = DirItems[i].Name;
                    i++;
                }
            }

            if ( i >= MAX_DIRS )
                break;
        }


    }

    if ( ( i == 0 ) && strcmp( CurrentPath, "" ) ) /* empty dir ?*/
    {
        mem_set( ( void* )DirItems[i].Name, 0, MAXDIRNAMELEN );
        mem_cpy( DirItems[i].Name, "[..]", 4 );
        DirMenu.Items[i].Text = DirItems[i].Name;
        DirItems[i].flags |= FS_ATTR_DIRECTORY; /* set flag in local list*/
        i++;
    }

    /* Set number of items in list (i + cde "Quit")*/
    DirMenu.Items[i].Text = "Quit";
    i++;
    DirMenu.NbItems = i;
    DirMenu.NbDisp = i > MAX_LIST_ITEMS_DISP ? MAX_LIST_ITEMS_DISP : i;

    DirMenu.XPos  = 0;
    DirMenu.YPos  = 150;
    DirMenu.XSize = 128;
    DirMenu.YSize = 140;
}

/*******************************************************************************
*
*                            FS_Explorer_Ini
*
*******************************************************************************/
NODEBUG2 enum MENU_code FS_Explorer_Ini( void )
{
    DirMenu.fdispTitle = 1;
    DirMenu.Title = " SDCard ";
    DirMenu.NbItems = 30;
//YRT130605    DirMenu.LgMax = 20;
    DirMenu.LgMax = MAX_PATH_LENGTH;
    DirMenu.XPos =  DirMenu.YPos = 0;
    DirMenu.XSize = DirMenu.YSize = 0;
    DirMenu.NbDisp = MAX_LIST_ITEMS_DISP;    /* Number of lines to be displayed*/
    DirMenu.SelectedItem = 0;                /* Current selected item*/
    DirMenu.FirstDisplayItem = 0;            /* Index of the first displayed item*/

    mem_set( CurrentPath, 0, sizeof( CurrentPath ) );

    SDCardfault = 0;
    SD_DeInit();

    /* Mount MMCSD if necessary */
    StartMBR = FS_Mount( MMCSD_SDIO );

    if ( StartMBR != FR_OK )
    {
        // Try another time (pb in SPI mode)
        StartMBR = FS_Mount( MMCSD_SDIO );
        if ( StartMBR != FR_OK )
        {
            DirMenu.Items[0].Text = "No SD Card";
            SDCardfault = 1;
        }
    }

    if ( !SDCardfault )
    {
        // Open volume on first partition (0)
        if ( FS_GetVolumeInfo( 0, StartMBR, &volume_info ) )
        {
            DirMenu.Items[0].Text = "Err: GetVolInfo";
            SDCardfault = 1;
        }
    }

    if ( !SDCardfault )
    {
        // Open root directory
        if ( FS_OpenDirectory( &volume_info, "", &directory_info ) )
        {
            DirMenu.Items[0].Text = "Err: Open Root";
            SDCardfault = 1;
        }
    }

    if ( SDCardfault )
    {
        // 2 items : error msg + quit
        DirMenu.NbItems = 2;
        DirMenu.Items[1].Text = "Quit";

        // Show list
        LIST_Set( &DirMenu, 0, 0, 1 );
    }
    else
    {
        fileInfo.lfname = ( TCHAR* ) LfnBuf;
        fileInfo.lfsize = sizeof( LfnBuf );

        // Populate the list
        FS_Explorer_UpdateList();

        // Accelerate the menu divider
        Appli_DividerBkp = Appli_Divider;
        MENU_SetAppliDivider( 1 );

        // Show list
        LIST_Set( &DirMenu, 0, 0, 1 );

    }

    return MENU_CONTINUE_COMMAND;

}


/*******************************************************************************
*
*                            FS_Explorer
*
*******************************************************************************/
NODEBUG2 s32 FS_Explorer( void )
{
    s32 i;
    u32 retval;
    u8 EOP = 0;

    /* Call the List manager of the current list*/
    i = LIST_Manager();

    /* If item selected*/
    if ( i != -1 )
    {

        /* If choice different than quit and card OK*/
        if ( ( i != ( DirMenu.NbItems - 1 ) ) && !SDCardfault )
        {
            u8 dir[MAX_PATH_LENGTH];
            mem_set( dir, 0, sizeof( dir ) );

            /* Directory selected from list*/
            if ( DirItems[i].flags & FS_ATTR_DIRECTORY )
            {
                /* Check if we want to go up a level*/
                if ( !( strncmp( DirItems[i].Name + 1, "..", 2 ) ) )
                {
                    u8* ptr = CurrentPath + ( sizeof( CurrentPath ) - 1 );


                    /* Remove directory name from CurrentPath*/
                    for ( i = MAX_PATH_LENGTH; i > 0; i-- )
                    {
                        if ( ( *ptr == '/' ) && ( !EOP ) )
                        {
                            /* Found end of current path    */
                            EOP = 1;
                        }
                        else if ( ( *ptr == '/' ) && ( EOP ) )
                        {
                            break; /* erased subdir and found //*/
                        }
                        *ptr-- = 0;
                    }
                    //~ DFS_strcpy( dir, CurrentPath );
                    str_cpy( dir, CurrentPath );
                }
                else
                {
                    str_cpy( dir, CurrentPath );
                    len_t strLen = my_strlen( DirItems[i].Name );
                    strncat( dir, DirItems[i].Name + 1, strLen - 2 ); /* strip '[ ]'*/
                }

                /* Open directory*/
                if ( (retval = FS_OpenDirectory( &volume_info, dir, &directory_info )) )
                {
                    /* Cannot open dir*/
                    /* add error handling. Go back to root for now*/
                    if ( ( retval == FR_NO_PATH ) ||
                            ( retval == FR_INVALID_NAME ) )
                    {
                        FS_OpenDirectory( &volume_info, "", &directory_info );
                    }
                    /* Reset CurrentPath */
                    mem_set( CurrentPath, 0, sizeof( CurrentPath ) );
                }
                else
                {
                    /* Check if we didn't go up*/
                    if ( !EOP )
                    {
                        u8 len = my_strlen( CurrentPath );
                        u8 j;

                        /* Remove trailing spaces*/
                        for ( j = len; j > 0; j-- )
                        {
                            if ( CurrentPath[j] == 0x20 )
                                CurrentPath[j] = 0;
                        }

                        /* Add new dir to current path*/
                        len_t strLen = my_strlen( DirItems[i].Name );
                        strncat( CurrentPath, DirItems[i].Name + 1, strLen - 2 ); /* strip '[ ]'*/

                        /* Remove trailing spaces again*/
                        len = my_strlen( CurrentPath );
                        for ( j = len; j > 0; j-- )
                        {
                            if ( CurrentPath[j] == 0x20 )
                                CurrentPath[j] = 0;
                        }

                        /* Add dir seperator*/
                        strcat( CurrentPath, "/" );
                    }
                }

                /* Update directory list*/
                FS_Explorer_UpdateList();

                /* Clear display*/
                DRAW_Clear();

                /* Show list*/
                DirMenu.NbDisp = MAX_LIST_ITEMS_DISP;
                LIST_Set( &DirMenu, 0, 0, 1 );

            } /* end (DirItems[i].flags & FS_ATTR_DIRECTORY)*/
            else
                /* File selected from list*/
            {
                // Add file name to the path
                len_t strLen = my_strlen( DirItems[i].Name );
                strncat( CurrentPath, DirItems[i].Name, strLen + 1 );
                //FS_Unmount( MMCSD_SDIO );     //YRT130605 Let the file system mounted for the calling app
            
               // MENU_RestoreAppliDivider();   //YRT1307123 Let the divider restored by the calling app
                return 1;
            }

        } /* end (i != (DirMenu.NbItems - 1) )  && !SDCardfault)*/
        else
        {
            /* Quit requested*/
            //FS_Unmount( MMCSD_SDIO );     //YRT130605 Let the file system mounted for the calling app

            // Restore application divider
            //MENU_RestoreAppliDivider();   //YRT1307123 Let the divider restored by the calling app

            return 0;
        }

    } /* end (i != -1)*/

    return -1;
}

/*******************************************************************************
* Function Name  : NVIC_Config_SDIO
* Description    : Configures SDIO IRQ channel.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
NODEBUG void NVIC_Config_SDIO( void )
{
#if SDCARD_SDIO
    NVIC_InitTypeDef NVIC_InitStructure;

    /* Configure the NVIC Preemption Priority Bits */
    NVIC_PriorityGroupConfig( NVIC_PriorityGroup_1 );

    NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init( &NVIC_InitStructure );

    NVIC_InitStructure.NVIC_IRQChannel = SD_SDIO_DMA_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_Init( &NVIC_InitStructure );
#endif
}