fat.c

Go to the documentation of this file.

/***************************************************************************
 * fat.c
 * (C) 2010 Ivan Meleca
 * Based on original code written by Ruben Meleca
 * www.milos.it
 *
 *
 * Interface between ChaN's FatFs and Milos (EXPERIMENTAL) *
 *
 * FatFS Copyright (C) 2010, ChaN, all right reserved.
 * http://elm-chan.org/fsw/ff/00index_e.html
 *

#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software
#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 *
 * The function names and some types names are the same as previous versions
 * of Milos (to keep compatibility).
 * This file intends to "glue" the Milos implementation with the FatFS file
 * system. Some types (mostly error codes)are the same from FatFS, so expect
 * naming differences (by default all Milos names start with a double underscore
 * character to differentiate them from user (app) functions and avoid renaming).
 * Let's say this file will suffer modifications: one issue is the mentioned
 * above. The other is that someday we will (hopefully) implement diverse
 * file systems, and the __fileXXXXX functions should be the same for different
 * file system types.
 *
***************************************************************************/

#include "fat.h"
#include <core/heap.h>
#include <core/device.h>
#include <drivers/sd/sd.h>
#include <common/mem.h>
#include <common/string.h>
#include <core/dbgterm.h>
#include <core/rtc.h>

#if __CONFIG_COMPILE_FAT

__PFAT_VOLUME   __fatVolumes;       
 __PFAT_VOLUME __fatGetVolumeFromFatFS(__PFAT_FATFS fs)
{
    __PFAT_VOLUME vol = __fatVolumes;
    while (vol)
    {
        if (vol->fat == fs) return vol;
        vol = vol->next;
    }

    return __NULL;
}

__STATIC __PDEVICE __fatGetDevice(u8 drv)
{
    __PFAT_VOLUME vol = __fatVolumes;
    while (vol)
    {
        if (vol->num == drv) return vol->dv;
        vol = vol->next;
    }

    return __NULL;
}

__STATIC __PFAT_VOLUME __fatCreateVolume(u8 num, __PFAT_FATFS fat, __PDEVICE dv)
{
    __PFAT_VOLUME ptr = __fatVolumes;
    __PFAT_VOLUME last = ptr;

    __systemStop();

    /* Find a position */
    while (ptr)
    {
        last = ptr;
        ptr = ptr->next;
    }

    ptr = (__PFAT_VOLUME) __heapAllocZero(sizeof(__FAT_VOLUME));
    if (!ptr) return __NULL;

    ptr->num = num;
    ptr->fat = fat;
    ptr->dv = dv;
    ptr->next = __NULL;

    if (!last)
    {
        __fatVolumes = ptr;
    } else
    {
        last->next = ptr;
    }

    __systemStart();

    return ptr;
}

__STATIC __VOID __fatFreeVolume(__PFAT_VOLUME vol)
{
    __PFAT_VOLUME ptr = __fatVolumes;
    __PFAT_VOLUME last = ptr;

    __systemStop();

    /* Find the position */
    while (ptr) {
        if (ptr == vol)
        {
            if (vol == __fatVolumes)
            {
                __fatVolumes = __fatVolumes->next;
            } else
            {
                last->next = ptr->next;
            }

            __heapFree(vol);
        }
        last = ptr;
        ptr = ptr->next;
    }
}

__PFAT_VOLUME __fatMount(u8 num, __PDEVICE dv)
{
    __PFAT_VOLUME ptr = __fatVolumes;
    __PFAT_FATFS fat;

    /* Check if num is already mounted */
    while (ptr)
    {
        if (ptr->num == num) return ptr;
        ptr = ptr->next;
    }

    /* Create a new __PFAT_FATFS, the object that FatFS uses to store
     * FAT information.
     */
    fat = (__PFAT_FATFS) __heapAllocZero(sizeof(__FAT_FATFS));
    if (!fat) return __NULL;

    /* Call FatFS f_mount */
    if (f_mount(num, fat) != FR_OK)
    {
        __heapFree(fat);
        return __NULL;
    }

    /* Create and store a new volume */
    ptr = __fatCreateVolume(num, fat, dv);

    /* Return valid pointer on success, otherwise __FALSE */
    return ptr;
}

__VOID __fatDismount(__PFAT_VOLUME vol)
{
    /* Save fat pointer*/
    __PFAT_FATFS fat = vol->fat;

    /* Call f_mount */
    f_mount(vol->num, __NULL);

    __fatFreeVolume(vol);
    __heapFree(fat);
}

/* TODO */
u32 __fatGetFreeClusters(__CONST __PSTRING part, __PFAT_VOLUME* vol);

__FILE_RES __dirCreate(__CONST __PSTRING name)
{
    return f_mkdir(name);
}

__FILE_RES __dirOpen(__PDIR dir, __CONST __PSTRING name)
{
    return f_opendir(dir, name);
}

__FILE_RES __dirRead(__PDIR dir, __PFILEINFO fi)
{
    return f_readdir(dir, fi);
}

#if __CONFIG_COMPILE_DBGTERM

__VOID __fatDirCmd(__PTERMINAL term)
{
    __DIR dir;
    __FILEINFO fi;
    __PSTRING str;
    u32 count = 0;
    u32 bytes = 0;

    /* String buffer */
    str = __heapAllocZero(64);
    if (!str) return;

    /* Clean */
    __memSet(&dir, 0, sizeof(dir));
    __memSet(&fi, 0, sizeof(fi));

    /* Call root __dirOpen() */
    if (__dirOpen(&dir, "") == FR_OK)
    {
        __terminalWriteLine(term, "\r\nFiles in FAT:\r\n");
        __terminalWriteLine(term, "Name           Size");
        __terminalWriteLine(term, "-------------------------");

        /* First call to __dirRead() with __NULL fi */
        __dirRead(&dir, __NULL);

        /* While files in dir */
        while (__dirRead(&dir, &fi) == FR_OK && dir.sect > 0)
        {
            count++;
            bytes += fi.fsize;
            __strFmt(str, "%12s   %lu bytes", fi.fname, (u32) fi.fsize);
            __terminalWriteLine(term, str);
        }

        __terminalWriteLine(term, "\r\n%lu file(s) %lu bytes\r\n", count, bytes);
    } else
    {
        __terminalWriteLine(term, "Error calling __dirOpen()");
    }

    __heapFree(str);
}

#endif /* __CONFIG_COMPILE_DBGTERM */

__PFILE __fileOpen(__CONST __PSTRING file, u8 mode)
{
    __PFILE ptr;

    ptr = (__PFILE) __heapAllocZero(sizeof(__FILE));
    if (!ptr) return __NULL;

    if (f_open(ptr, file, mode) != FR_OK)
    {
        __heapFree(ptr);
        return __NULL;
    }

    return ptr;
}

u32 __fileRead(__PFILE file, __PVOID buf, u32 qty)
{
    UINT ret = 0;

    f_read(file, buf, qty, &ret);
    return ret;
}

__FILE_RES  __fileSeek(__PFILE file, u32 offs)
{
    return f_lseek(file, offs);
}

__FILE_RES  __fileClose(__PFILE file)
{
    __FILE_RES ret;
    ret = f_close(file);
    if (ret == FR_OK) {
        __heapFree(file);
    }

    return ret;
}

__FILE_RES  __fileGetStatus(__CONST __PSTRING file, __PFILEINFO fi)
{
    return f_stat(file, fi);
}

u32 __fileWrite(__PFILE file, __PVOID buf, u32 qty)
{
    UINT ret;
    f_write(file, buf, qty, &ret);
    return ret;
}

__FILE_RES __fileFlush(__PFILE file)
{
    return f_sync(file);
}

__FILE_RES  __fileTruncate(__PFILE file)
{
    return f_truncate(file);
}

__FILE_RES  __fileDelete(__CONST __PSTRING file)
{
    return f_unlink(file);
}

__FILE_RES  __fileChmod(__CONST __PSTRING file, u8 value, u8 mask)
{
    return f_chmod(file, value, mask);
}

__FILE_RES  __fileChangeTime(__CONST __PSTRING file, __CONST __PFILEINFO fi)
{
    return f_utime(file, fi);
}

__FILE_RES  __fileRename(__CONST __PSTRING name1, __CONST __PSTRING name2);

__FATFS_STATUS disk_initialize (u8 drv)
{
    /* Get the device */
    __PDEVICE dv = __fatGetDevice(drv);
    if (!dv) return RES_NOTRDY;

    /* Call __deviceOpen. The device should return 0 on success.
     * The device should be already registered with __deviceRegister().
     */
    if (__deviceOpen(dv, 0) == 0) return RES_OK;
    return RES_ERROR;
}

__FATFS_STATUS disk_status (BYTE drv)
{
    __FATFS_STATUS ret = 0;
    __PDEVICE dv;

    /* Get the device */
    dv = __fatGetDevice(drv);
    if (!dv) return ret;

    switch (dv->dv_type)
    {
        /* SD/CF? */
        case __DEV_CFSD:
            if (__deviceIOCtl(dv, __IOCTL_WRITE_PROTECTED, 0, __NULL, 0))
            {
                ret |= STA_PROTECT;
            }

            if (!__deviceIOCtl(dv, __IOCTL_MEDIA_AVAILABLE, 0, __NULL, 0))
            {
                ret |= STA_NODISK;
            }
            break;
        default:
            /* TODO */
            ret = STA_NOINIT;
            break;
    }

    if (!dv->dv_initd || !dv->dv_opcnt)
    {
        ret |= STA_NOINIT;
    }
    return ret;
}

__FATFS_RES disk_ioctl (u8 drv, u8 ctrl, __PVOID buff)
{
    __FATFS_RES res = RES_ERROR;
    u8* ptr = (u8*) buff;
    __PDEVICE dv;

    /* Get the device */
    dv = __fatGetDevice(drv);
    if (!dv) return res;

    /* SC/CF? */
    if (dv->dv_type == __DEV_CFSD)
    {
        /* Power control code */
        if (ctrl == CTRL_POWER)
        {
            switch (*ptr) {
                /* Power off */
                case 0:
                    if (__deviceIOCtl(dv, __IOCTL_GET_POWER_STATUS, 0, __NULL, 0)) {
                        __deviceIOCtl(dv, __IOCTL_SET_POWER_STATUS, 0, __NULL, 0);
                    }
                    res = RES_OK;
                    break;

                /* Power on */
                case 1:
                    __deviceIOCtl(dv, __IOCTL_SET_POWER_STATUS, 1, __NULL, 0);
                    res = RES_OK;
                    break;

                /* Get power status */
                case 2:
                    *(ptr+1) = (u8) __deviceIOCtl(dv, __IOCTL_GET_POWER_STATUS, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                default:
                    res = RES_PARERR;
                    break;
            }
        } else
        {
            /* The next control codes need the device in ready state */
            if (disk_status(drv) & STA_NOINIT) return RES_NOTRDY;

            switch (ctrl)
            {
                /* Make sure that the disk drive has finished pending write process.
                 * When the disk I/O module has a write back cache, flush the dirty
                 * sector immediately. This command is not used in read-only configuration.
                 */
                case CTRL_SYNC:
                    /* TODO flush cache */
                    res = RES_OK;
                    break;

                /* Returns number of available sectors on the drive into the DWORD variable
                 * pointed by Buffer. This command is used by only f_mkfs function to determine
                 * the volume size to be created.
                 */
                case GET_SECTOR_COUNT:
                    *(u32*) buff = __deviceIOCtl(dv, __IOCTL_GET_SECTOR_COUNT, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                /* Returns sector size of the drive into the WORD variable pointed by Buffer.
                 * This command is not used in fixed sector size configuration, _MAX_SS is 512.
                 */
                case GET_SECTOR_SIZE:
                    *(u16*) buff = 512;
                    res = RES_OK;
                    break;

                /* Returns erase block size of the flash memory in unit of sector into the
                 * DWORD variable pointed by Buffer. The allowable value is 1 to 32768 in power
                 * of 2. Return 1 if the erase block size is unknown or disk devices. This command
                 * is used by only f_mkfs function and it attempts to align data area to the erase
                 * block boundary.
                 */
                case GET_BLOCK_SIZE:
                    *(u32*) buff = __deviceIOCtl(dv, __IOCTL_GET_BLOCK_SIZE, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                /* Get card type */
                case MMC_GET_TYPE:
                    *ptr = (u8) __deviceIOCtl(dv, __IOCTL_GET_CARD_TYPE, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                case MMC_GET_CSD:
                     __deviceIOCtl(dv, __IOCTL_GET_CSD, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                case MMC_GET_CID:
                    __deviceIOCtl(dv, __IOCTL_GET_CID, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                case MMC_GET_OCR:
                    __deviceIOCtl(dv, __IOCTL_GET_OCR, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                case MMC_GET_SDSTAT:
                    __deviceIOCtl(dv, __IOCTL_GET_SDSTAT, 0, __NULL, 0);
                    res = RES_OK;
                    break;

                default:
                    res = RES_PARERR;
                    break;
            }
        }
    }

    return res;
}

__FATFS_RES disk_read (u8 drv, u8 *buff, u32 sector, u8 count)
{
    __PDEVICE dv;

    /* Get the device */
    dv = __fatGetDevice(drv);
    if (!dv) return RES_PARERR;

    /* Set the sector to read */
    if (dv->dv_type == __DEV_CFSD) __deviceIOCtl(dv, __IOCTL_SET_SECTOR, sector, __NULL, 0);
    if (__deviceRead(dv, buff, count) == 0) return RES_OK;

    return RES_ERROR;
}

__FATFS_RES disk_write (BYTE drv, __CONST u8 *buff, u32 sector, u8 count)
{
    __PDEVICE dv;

    /* Get the device */
    dv = __fatGetDevice(drv);
    if (!dv) return RES_PARERR;

    if (dv->dv_type == __DEV_CFSD)
    {
        if (__deviceIOCtl(dv, __IOCTL_WRITE_PROTECTED, 0, __NULL, 0))
        {
            return RES_WRPRT;
        }
    }

    /* Set the sector to write */
    if (dv->dv_type == __DEV_CFSD)
    {
        __deviceIOCtl(dv, __IOCTL_SET_SECTOR, sector, __NULL, 0);
    }

    /* Write */
    if (__deviceWrite(dv, buff, count) == 0) return RES_OK;

    return RES_ERROR;
}

u32 get_fattime (__VOID)
{

#if __CONFIG_COMPILE_RTC
    __DATETIME dt;

    __rtcGetDateTime(&dt);

    return ((dt.year - 1980) << 25  |
             dt.month << 21         |
             dt.day << 16           |
             dt.hour << 11          |
             dt.min << 5            |
             dt.sec);

#else

    /* fixed date-time */
    return (30 << 25 | 12 << 21 | 30 << 16 | 19 << 11 | 2 << 5 | 50);

#endif /* __CONFIG_COMPILE_RTC */

}

#if _FS_REENTRANT

__BOOL ff_cre_syncobj (u8 vol, _SYNC_t *sobj)
{
    __BOOL ret = __FALSE;

    *sobj = __lockCreate();
    ret = (*sobj != __NULL) ? __TRUE : __FALSE;

    return ret;
}


BOOL ff_del_syncobj (_SYNC_t sobj) {
    __lockDestroy(sobj);
    return __TRUE;
}

BOOL ff_req_grant(_SYNC_t sobj) {
__BOOL ret;

    ret = __lockOwn(sobj, _FS_TIMEOUT);
    return ret;
}

__VOID ff_rel_grant (_SYNC_t sobj)
{
    __lockRelease(sobj);
}

#endif


#if _USE_LFN == 3   /* LFN with a working buffer on the heap */

__PVOID ff_memalloc (UINT size)
{
    return __heapAlloc(size);
}

__VOID ff_memfree(__PVOID mblock)
{
    __heapFree(mblock);
}

#endif // _USE_LFN

#endif // __CONFIG_COMPILE_FAT