ArduinoFs.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_ARDUINO_ARDUINOFS_HXX_
#define _FREERTOS_DRIVERS_ARDUINO_ARDUINOFS_HXX_
 
#ifndef ARDUINO_ARCH_STM32
#error This module only works for STM32 boards.
#endif
 
#ifndef OPENMRN_HAVE_POSIX_FD
#error You must add a file build_opt.h to the sketch directory and add -DOPENMRN_HAVE_POSIX_FD to it to make use of this module.
#endif
 
#include "stm32_eeprom.h"
#include <errno.h>
 
#define EEPROM_FILENAME "/dev/eeprom"
 
class FsStatic
{
public:
    static constexpr unsigned MAX_FD = 8;
    static constexpr off_t UNUSED_FILE = (off_t)-1;
 
    struct FileInfo
    {
        off_t offset = UNUSED_FILE;
 
        bool in_use()
        {
            return offset != UNUSED_FILE;
        }
 
        void open()
        {
            offset = 0;
        }
 
        void close()
        {
            offset = UNUSED_FILE;
        }
    };
 
    static FileInfo fds[MAX_FD];
 
    static FileInfo *get_file(int fd)
    {
        if (fd >= MAX_FD || !fds[fd].in_use())
        {
            errno = EBADF;
            return nullptr;
        }
        return &fds[fd];
    }
 
    static int new_fd()
    {
        for (int fd = 0; fd < MAX_FD; ++fd)
        {
            if (!fds[fd].in_use())
            {
                fds[fd].open();
                return fd;
            }
        }
        errno = ENFILE;
        return -1;
    }
 
    static void flush_if_dirty()
    {
        if (dirty_)
        {
            eeprom_buffer_flush();
            dirty_ = 0;
        }
    }
 
    static uint8_t loaded_;
    static uint8_t dirty_;
};
 
FsStatic::FileInfo FsStatic::fds[FsStatic::MAX_FD];
uint8_t FsStatic::loaded_ = 0;
uint8_t FsStatic::dirty_ = 0;
 
extern "C"
{
 
int _open_r(struct _reent *reent, const char *path, int flags, int mode)
{
    if (strcmp(path, EEPROM_FILENAME) != 0)
    {
        errno = ENOENT;
        return -1;
    }
    if (!FsStatic::loaded_)
    {
        eeprom_buffer_fill();
        FsStatic::loaded_ = 1;
    }
    return FsStatic::new_fd();
}
 
int _close_r(struct _reent *reent, int fd)
{
    FsStatic::FileInfo *finfo = FsStatic::get_file(fd);
    if (!finfo)
    {
        return -1;
    }
    finfo->close();
    FsStatic::flush_if_dirty();
    return 0;
}
 
ssize_t _read_r(struct _reent *reent, int fd, void *buf, size_t count)
{
    FsStatic::FileInfo *finfo = FsStatic::get_file(fd);
    if (!finfo)
    {
        return -1;
    }
    ssize_t ret = 0;
    uint8_t *dst = (uint8_t *)buf;
    int left = (int)E2END - (int)finfo->offset;
    if (left < 0)
    {
        left = 0;
    }
    if (left < count)
    {
        count = left;
    }
    while (count > 0)
    {
        *dst = eeprom_buffered_read_byte(finfo->offset);
        ++dst;
        ++finfo->offset;
        --count;
        ++ret;
    }
    return ret;
}
 
ssize_t _write_r(struct _reent *reent, int fd, const void *buf, size_t count)
{
    FsStatic::FileInfo *finfo = FsStatic::get_file(fd);
    if (!finfo)
    {
        return -1;
    }
    ssize_t ret = 0;
    const uint8_t *src = (const uint8_t *)buf;
    int left = (int)E2END - (int)finfo->offset;
    if (left < 0)
    {
        left = 0;
    }
    if (left < count)
    {
        count = left;
    }
    if (count)
    {
        FsStatic::dirty_ = 1;
    }
    while (count > 0)
    {
        eeprom_buffered_write_byte(finfo->offset, *src);
        ++src;
        ++finfo->offset;
        --count;
        ++ret;
    }
    return ret;
}
 
int fsync(int fd)
{
    FsStatic::FileInfo *finfo = FsStatic::get_file(fd);
    if (!finfo)
    {
        return -1;
    }
    FsStatic::flush_if_dirty();
    return 0;
}
 
int _stat_r(struct _reent *reent, const char *path, struct stat *stat)
{
    if (strcmp(path, EEPROM_FILENAME) != 0)
    {
        errno = ENOENT;
        return -1;
    }
    memset(stat, 0, sizeof(*stat));
    stat->st_size = E2END;
    return 0;
}
 
int _fstat_r(struct _reent *reent, int fd, struct stat *stat)
{
    FsStatic::FileInfo *finfo = FsStatic::get_file(fd);
    if (!finfo)
    {
        return -1;
    }
    memset(stat, 0, sizeof(*stat));
    stat->st_size = E2END;
    return 0;
}
 
_off_t _lseek_r(struct _reent *reent, int fd, _off_t offset, int whence)
{
    FsStatic::FileInfo *finfo = FsStatic::get_file(fd);
    if (!finfo)
    {
        return -1;
    }
    off_t new_offset = finfo->offset;
    switch (whence)
    {
        case SEEK_SET:
            new_offset = offset;
            break;
        case SEEK_CUR:
            new_offset += offset;
            break;
        case SEEK_END:
            new_offset = E2END + offset;
            break;
        default:
            new_offset = E2END + 1;
    }
    if (new_offset > E2END)
    {
        errno = EINVAL;
        return -1;
    }
    finfo->offset = new_offset;
    return new_offset;
}
 
} // extern "C"
 
#endif // _FREERTOS_DRIVERS_ARDUINO_ARDUINOFS_HXX_