/* **************************************************************************** * Описание: эта функция принимает символ c, и если это недопустимый символ * * для имени FAT, то возвращает символ 'X'. если это буква в нижнем регистре, * * возвращается эквивалент в верхнем регистре. Остальные символы передаются * * как есть, без изменений. * * Возвращаемое значение: приведенный "верный" символ * ******************************************************************************/ euint8 file_validateChar(euint8 c) { if( (c < 0x20) || (c > 0x20 && c < 0x30 && c != '-' && c != '%') || (c > 0x39 && c < 0x41) || (c > 0x5A && c < 0x61 && c != '_') || (c > 0x7A && c < 0x80 && c != '~') || (c > 0xAF && c < 0xE0) || (c > 0xEF)) return(0x58); if( c >= 0x61 && c < = 0x7A ) return(c-32); return(c); }

/* ***************************************************************************\ Заполняет поля параметра file -> DirEntry. В случае успеха возвращает 0. */ esint8 getFileRecord (File* file, FileSystem *fs, eint8* filename) { FileLocation loc; if(fs_findFile(fs,filename,&loc,0)==1) { dir_getFileStructure(fs,&file -> DirEntry,&loc); return 0; } return -1; }

EmbeddedFileSystem efsl;
...
//инициализируем файловую систему
if (!efs_initialized)
{
    if ( efs_init (&efsl, 0) !=0 )
    {
        //printf ( "Could not open filesystem.\n" );
        ErrMsg();
        return;
    }
    else
    {
        efs_initialized = true;
    }
}
//открываем нужный путь
if (ls_openDir ( &list, &(efsl.myFs), arcpath ) != 0)
{
    //printf ( "Could not open list at %s.\n", arcpath );
    ErrMsg();
    memset (foldname, 0, sizeof(foldname));
    crm = CAT_READ_DIRS;
    return;
}
...
  
DirList list;
...
  
if (0 != ls_getNext (&list))
{
    //обработка ошибки
}
  
EmbeddedFile file;
char name[9];
char ext [4];
char full_path [TXTBUF_SIZE/*1 +8+1+3 +1 +8+1+3 +1*/];
memset(name, 0, sizeof(name));
memset(ext , 0, sizeof(ext ));
strncpy(name,(char*) list->currentEntry.FileName,  8);
strncpy(ext, (char*)&list->currentEntry.FileName[8],3);
trim(name);
trim(ext);
//теперь получим дату и время файла
strcpy(full_path, arcpath);
strcat(full_path, name);
strcat(full_path, ".");
strcat(full_path, ext);
if (0 != getFileRecord(&file,&efsl.myFs,full_path))
{
    //Обработка ошибки:
    printf ( "Can`t get file record %s.%s\n", name, ext );
    ...
}
else
{
    DecodeDate(file.DirEntry.WriteDate);
    DecodeTime(file.DirEntry.WriteTime);
}
  
char* DecodeDate (u16 date)
{
    u8 m, d;
    char y[5];
  
    sprintf (y,"%4i", 1980 + ((date >> 9)&0x3F));
    m = (date >> 5)&0x0F;
    d = date & 0x1F;
    sprintf (datestr, "%02i.%02i.%s", d, m, &y[2]);
    datestr[8] = 0;
    return datestr;
}
  
char* DecodeTime (u16 time)
{
    u8 h, m, s;
    h = (time >> 11)&0x1F;
    m = (time >> 5) &0x3F;
    s = (time      &0x1F) * 2;
    sprintf (timestr, "%02i:%02i:%02i", h, m, s);
    timestr[8] = 0;
    return timestr;
}

/* ****************************************************************************
* esint16 rmdir (FileSystem *fs, euint8* dir)
* Description: функция удаляет папку по имени, путем освобождения её цепочки
* кластеров, и удаления его записи из директории.
* Return value: 0 если О.К., -1 при ошибке типа файл не найден.
*/
esint16 rmdir (FileSystem *fs, euint8* dir)
{
    FileLocation loc;
    ClusterChain cache;
    euint8* buf;
    euint32 firstCluster=0;
    if((fs_findFile(fs, (eint8*)dir, &loc,0))==2)
    {
        buf=part_getSect(fs->part,loc.Sector,IOM_MODE_READWRITE);
        firstCluster = ex_getb16(buf,loc.Offset*32+20);
        firstCluster << = 16;
        firstCluster += ex_getb16(buf,loc.Offset*32+26);
        /* Bugfix:
 * Очищая всю структуру, Вы отмечаете конец каталога.
 * Если не этот случай, то файлы дальше не могут быть больше открыты
 * реализациями, которые соответствуют стандарту. */
        /*memClr(buf+(loc.Offset*32),32);*/
        *(buf+(loc.Offset*32)+0) = 0xE5; /* Пометить файл удаленным */
        part_relSect(fs -> part,buf);
        cache.DiscCluster = cache.LastCluster = cache.Linear = cache.LogicCluster = 0;
        cache.FirstCluster = firstCluster;
        fat_unlinkClusterChain(fs,&cache);
        return(0);
    }
    return(-1);
}

short listFiles(FileSystem *fs, char *dirname)
{
    unsigned long startCluster;
    unsigned char fileEntryCount;
    unsigned short counter=0;
    unsigned long offset=0;
    FileRecord fileEntry;
    FileLocation loc;
    unsigned char buf[512];
    File dir;
    unsigned short i;
    /* Проверка - поиск идет в корневом каталоге, или нет */
    if(dirname[0]=='/' && dirname[1]=='\0')
    {
        if( (fs -> type == FAT12) || (fs -> type == FAT16) )
        {
            for(i=0; i < = (fs -> volumeId.RootEntryCount/16); i++)
            {
                loc.Sector=fs -> FirstSectorRootDir + i;
                part_readBuf(fs -> part,loc.Sector,buf);
                /* I STOPPED HERE*/
                /* FIXME */
            }
        }
    }
    else /* Обычная директория */
    {
        /* Проверка - указывает ли путь на директорию */
        if(fs_findFile(fs,dirname,&loc,0)!=2)
        {
            //FUNC_OUT((TXT("")));
            return(-1);
        }
        /* Узнаем начальный кластер каталога директории */
        part_readBuf(fs -> part, loc.Sector, buf);
        fileEntry = *(((FileRecord*)buf) + loc.Offset);
        startCluster = (((unsigned long)fileEntry.FirstClusterHigh) << 16)
            + fileEntry.FirstClusterLow;
        /* Инициализация директории */
        dir.fs=fs;
        dir.Cache.LogicCluster=-1;
        dir.Cache.FirstCluster=startCluster;
        dir.DirEntry.Attribute=ATTR_DIRECTORY;
        file_setAttr(&dir, FILE_STATUS_OPEN, 1);
        dir.FileSize = (euint32)(-1);
        while((file_fread(&dir,offset,512,buf)))
        {
            DBG((TXT("Read 512 bytes from dir with offset %li.\n"),offset));
            for(fileEntryCount=0; fileEntryCount < 16; fileEntryCount++)
            {
                fileEntry = *(((FileRecord*)buf) + fileEntryCount);
                if( !( (fileEntry.Attribute & 0x0F) == 0x0F ) )
                {
                    if (fileEntry.FileName[0] == 0xE5)
                        continue;
                    if
                    (
                     (fileEntry.FileName[0] > = 'A' && fileEntry.FileName[0] < = 'Z')
                     ||
                     (fileEntry.FileName[0] > = '0' && fileEntry.FileName[0] < = '9')
                     ||
                     (fileEntry.FileName[0] > = 'a' && fileEntry.FileName[0] < = 'z')
                     ||
                     (fileEntry.FileName[0] > = 0x80)
                    )
                    {
                        DBG((TXT("Filename: %s\n"),fileEntry.FileName));
                        counter++;
                    }
                }
            }
            offset+=512;
        }
    }
    FUNC_OUT((TXT("")));
    file_setAttr(&dir, FILE_STATUS_OPEN, 0);
    return(counter);
}

if(!(ioman_writeSector(ioman, ioman -> sector[bufplace],buf)))
{
    ioman_setError(ioman,IOMAN_ERR_WRITEFAIL);
    return(-1);
}

if(-1 == ioman_writeSector(ioman, ioman -> sector[bufplace], buf))
{
    ioman_setError(ioman, IOMAN_ERR_WRITEFAIL);
    return(-1);
}
sc.c -> sd_writeSector

return(0);

return(1);

/*****************************************************************************\
* efs - General purpose Embedded Filesystem library *
* --------------------- ----------------------------------- *
* *
* Filename : types.h *
* Description : Headerfile for types.c *
* *
* (c)2006 Lennart Yseboodt *
* (c)2006 Michael De Nil *
\*****************************************************************************/
#ifndef __TIME_H_
#define __TIME_H_
/*****************************************************************************/
#include "types.h"
/*****************************************************************************/
#ifdef DATE_TIME_SUPPORT
  #define time_getYear(void) efsl_getYear()
  #define time_getMonth(void) efsl_getMonth()
  #define time_getDay(void) efsl_getDay()
  #define time_getHour(void) efsl_getHour()
  #define time_getMinute(void) efsl_getMinute()
  #define time_getSecond(void) efsl_getSecond()
  #define time_getDate(void) fs_makeDate()
  #define time_getTime(void) fs_makeTime()
#else
  #define time_getYear(void) 0x0;
  #define time_getMonth(void) 0x0;
  #define time_getDay(void) 0x0;
  #define time_getHour(void) 0x0;
  #define time_getMinute(void) 0x0;
  #define time_getSecond(void) 0x0;
  #define time_getDate(void) 0x0;
  #define time_getTime(void) 0x0;
#endif
#ifdef DATE_TIME_SUPPORT
euint16 efsl_getYear(void);
euint8 efsl_getMonth(void);
euint8 efsl_getDay(void);
euint8 efsl_getHour(void);
euint8 efsl_getMinute(void);
euint8 efsl_getSecond(void);
#endif
euint8 fs_hasTimeSupport(void);
#endif

/*****************************************************************************\
* efs - General purpose Embedded Filesystem library *
* --------------------- ----------------------------------- *
* *
* Filename : time.c *
* Description : This file contains functions for time support *
* *
* (c)2006 Lennart Yseboodt *
* (c)2006 Michael De Nil *
\*****************************************************************************/
  
/*****************************************************************************/
#include "time.h"
#include "arm7_efsl_0_2_7\inc\fs.h"
/*****************************************************************************/
  
#include "include/settings.h"
#include "include/vars.h"
  
euint16 efsl_getYear(void)
{
    //return(2005);
    return(2000 + 10*(currTime.Year >> 4) + (currTime.Year & 0x0F));
}
  
euint8 efsl_getMonth(void)
{
    //return(5);
    return (10*(currTime.Month >> 4) + (currTime.Month & 0x0F));
}
  
euint8 efsl_getDay(void)
{
    //return(11);
    return (10*(currTime.Day>>4) + (currTime.Day&0x0F));
}
euint8 efsl_getHour(void)
{
    //return(13);
    return (10*(currTime.Hour >> 4) + (currTime.Hour & 0x0F));
}
  
euint8 efsl_getMinute(void)
{
    //return(14);
    return (10*(currTime.Minute>>4) + (currTime.Minute&0x0F));
}
  
euint8 efsl_getSecond(void)
{
    //return(40);
    return (10*(currTime.Second>>4) + (currTime.Second&0x0F));
}
  
euint16 fs_makeDate(void)
{
#ifndef DATE_TIME_SUPPORT
    return(0);
#else
    euint8 m,d;
    euint16 y;
    
    y = time_getYear()-1980;
    m = time_getMonth();
    d = time_getDay();
    
    return(
        (y > 127? 127 << 9: (y & 0x3F) << 9)  |
        ((m == 0 || m > 12)? 1: (m & 0xF) << 5) |
        ((d == 0 || d > 31)? 1: (d & 0x1F))
    );
#endif
}
/*****************************************************************************/
euint16 fs_makeTime(void)
{
#ifndef DATE_TIME_SUPPORT
    return(0);
#else
    euint8 s,m,h;
    
    s = time_getSecond();
    m = time_getMinute();
    h = time_getHour();
    
    return(
        (h > 23? 0: (h & 0x1F) << 11) |
        (m > 59? 0: (m & 0x3F) << 5) |
        (s > 59? 0: (s-s%2)/2)
    );
#endif
}
/*****************************************************************************/
euint8 fs_hasTimeSupport(void)
{
#ifdef DATE_TIME_SUPPORT
    return(1);
#else
    return(0);
#endif
}
/*****************************************************************************/

esint8 if_initInterface(hwInterface* file, eint8* opts)
{
    euint32 sc;
    
    if_spiInit(file);
    if_spiInit(file);    //добавочный вызов инициализации интерфейса
    
    if(sd_Init(file) < 0)    
    {
        //printf("Card failed to init, breaking up...\n\r");
        return(-1);
    }
    
    if(sd_State(file) < 0)
    {
        //printf("Card didn't return the ready state, breaking up...\n\r");
        return(-2);
    }
    
    /* file -> sectorCount = 4; */ /* FIXME ASAP!! */
    /* mthomas: - somehow done - see below */
    sd_getDriveSize(file, &sc);
    file -> sectorCount = sc/512;
    if( (sc%512) != 0) 
        file -> sectorCount --;
    //DBG((TXT("Card Capacity is %u Bytes (%i Sectors)\n\r"), sc, file -> sectorCount));
    
    if_spiSetSpeed(SPI_SCBR_MIN);
    //if_spiSetSpeed(100); /* debug - slower */
    
    return(0);
}