klipper-dgus/scripts/spi_flash/fatfs_api.c

// Python CFFI bindings for fatfs
//
// Copyright (C) 2021 Eric Callahan <arksine.code@gmail.com>
//
// This file may be distributed under the terms of the GNU GPLv3 license.

#include <string.h>                     // memset
#include <stdlib.h>                     // malloc
#include "fatfs_api.h"                  // python-fatfs prototypes
#include "../../lib/fatfs/ff.h"         // fatfs APIs
#include "../../lib/fatfs/diskio.h"     // fatfs media APIs (callbacks)

/* Callbacks */
static uint8_t (*python_disk_status)(void) = 0;
static uint8_t (*python_disk_initialize)(void) = 0;
static uint8_t (*python_disk_read)(uint8_t* buff, uint32_t sector,
                                   unsigned int count) = 0;
static uint8_t (*python_disk_write)(const uint8_t* buff, uint32_t sector,
                                    unsigned int count) = 0;
static uint8_t (*python_disk_ioctl)(uint8_t cmd, void* buff) = 0;
static uint32_t (*python_fattime)(void) = 0;

void __visible
fatfs_set_callbacks(
    uint8_t (*status_callback)(void),
    uint8_t (*init_callback)(void),
    uint8_t (*read_callback)(uint8_t*, uint32_t, unsigned int),
    uint8_t (*write_callback)(const uint8_t*, uint32_t, unsigned int),
    uint8_t (*ioctl_callback)(uint8_t, void*),
    uint32_t (*fattime_callback)(void)
)
{
    python_disk_status = status_callback;
    python_disk_initialize = init_callback;
    python_disk_read = read_callback;
    python_disk_write = write_callback;
    python_disk_ioctl = ioctl_callback;
    python_fattime = fattime_callback;
}

void __visible
fatfs_clear_callbacks(void)
{
    python_disk_status = 0;
    python_disk_initialize = 0;
    python_disk_read = 0;
    python_disk_write = 0;
    python_disk_ioctl = 0;
    python_fattime = 0;
}

/*  Callbacks from fatfs to python.  These methods are used to  */
/*  Access access the SD Card APIs                              */

/*  Get FAT Time  */
DWORD
get_fattime(void)
{
    if (python_fattime == 0)
    {
        // Return a default FATTIME of 1/1/2021
        return 41 << 25 | 1 << 21 | 1 << 16;
    }
    return python_fattime();
}

DSTATUS
disk_status(BYTE pdrv)
{
    if (python_disk_status != 0)
        return python_disk_status();

    return STA_NOINIT;
}

DSTATUS
disk_initialize(BYTE pdrv)
{
    if (python_disk_initialize != 0)
        return python_disk_initialize();
    return STA_NOINIT;
}


DRESULT
disk_read(BYTE pdrv, BYTE *buff, LBA_t sector, UINT count)
{
    if (python_disk_read != 0)
        return python_disk_read(buff, sector, count);
    return RES_NOTRDY;
}


DRESULT
disk_write(BYTE pdrv, const BYTE *buff, LBA_t sector, UINT count)
{
    if (python_disk_write != 0)
        return python_disk_write(buff, sector, count);
    return RES_NOTRDY;
}

DRESULT
disk_ioctl(BYTE pdrv, BYTE cmd, void *buff)
{
    if (python_disk_ioctl != 0)
        return python_disk_ioctl(cmd, buff);
    return RES_NOTRDY;
}

/*  Python-FatFS Interface Functions  */

// Wrapper around the FatFS FIL struct.  FIL is type defined
// anonymously, thus can't be forward declared and poses
// challenges with CFFI.
struct ff_file {
    FIL fobj;
};
static FATFS fs;

uint8_t __visible
fatfs_mount(void)
{
    FRESULT res;
    memset(&fs, 0, sizeof(fs));
    res = f_mount(&fs, "", 1);
    return res;
}

uint8_t __visible
fatfs_unmount(void)
{
    FRESULT res;
    res = f_unmount("");
    memset(&fs, 0, sizeof(fs));
    return res;
}

struct ff_file* __visible
fatfs_open(const char* path, uint8_t mode)
{
    FRESULT res;
    struct ff_file* fhdl = malloc(sizeof(*fhdl));
    memset(fhdl, 0, sizeof(*fhdl));
    res = f_open(&(fhdl->fobj), path, mode);
    if (res != FR_OK) {
        free(fhdl);
        fhdl = NULL;
    }
    return fhdl;
}

uint8_t __visible
fatfs_close(struct ff_file* fhdl)
{
    FRESULT res;
    res = f_close(&(fhdl->fobj));
    free(fhdl);
    return res;
}

int __visible
fatfs_read(struct ff_file* fhdl, void* rbuf, uint16_t btr)
{
    FRESULT res;
    UINT bytes_read;
    res = f_read(&(fhdl->fobj), rbuf, btr, &bytes_read);
    if (res != FR_OK) {
        return -res;
    }
    return bytes_read;
}

int __visible
fatfs_write(struct ff_file* fhdl, const void* wbuf, uint16_t btw)
{
    FRESULT res;
    UINT bytes_written;
    res = f_write(&(fhdl->fobj), wbuf, btw, &bytes_written);
    if (bytes_written < btw) {
        return -res;
    }
    return bytes_written;
}

// Remove a file or director
uint8_t __visible
fatfs_remove(const char* path)
{
    FRESULT res;
    res = f_unlink(path);
    return res;
}

uint8_t __visible
fatfs_get_fstats(struct ff_file_info* finfo, const char* path)
{
    FRESULT res;
    FILINFO nfo;
    res = f_stat(path, &nfo);
    if (res == FR_OK)
        memcpy(finfo, &nfo, sizeof(nfo));
    return res;
}

uint8_t __visible
fatfs_get_disk_info(struct ff_disk_info* dinfo)
{
    FRESULT res;
    res = f_getlabel("", dinfo->label, &(dinfo->serial_number));
    if (res != FR_OK)
        return res;
    dinfo->fs_type = fs.fs_type;
    return res;
}

uint8_t __visible
fatfs_list_dir(struct ff_file_info* flist, uint8_t max_size, char* path)
{
    FRESULT res;
    DIR dir;
    FILINFO nfo;
    res = f_opendir(&dir, path);
    if (res == FR_OK) {
        for (uint8_t i=0; i < max_size; i++) {
            res = f_readdir(&dir, &nfo);
            if (res != FR_OK ||nfo.fname[0] == 0)
                break;
            memcpy(&(flist[i]), &nfo, sizeof(nfo));
        }
    }
    return FR_OK;
}