/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
#include <tffs.h>

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
/*--- #define DEBUG ---*/

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
#if defined(DEBUG)
#define DBG(a)  { printf a ; fflush(stdout); }
#else /*--- #if defined(DEBUG) ---*/
#define DBG(a)  
#endif /*--- #else ---*/ /*--- #if defined(DEBUG) ---*/

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
char *_tffs_device = "/dev/tffs/mtd3";

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
void tffs_device(const char *device) {
    _tffs_device = (char *)device;
}


/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
int tffs_open(int flags) {
    DBG(("tffs_open(flags=0x%x)\n", flags));
    return open(_tffs_device, flags);
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
int tffs_close(int fd) {
    DBG(("tffs_close(fd=0x%x)\n", fd));
    close(fd);
    return 0;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
int tffs_clear_value(int fd, enum _tffs_id id) {
    struct _tffs_cmd cmd;
    int ret;

    DBG(("clear_value(fd=%u, id=0x%x)\n", fd, id));

    cmd.id     = (enum _tffs_id)id;
    cmd.size   = 0;
    cmd.buffer = NULL;
    ret = ioctl(fd, TFFS_CLEAR_ID, &cmd);

    if(ret | cmd.status) {
        DBG(("clear_value failed ret=%d status=%d\n", ret, cmd.status));
    }

    return ret | cmd.status;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
int tffs_cleanup(int fd) {
    struct _tffs_cmd cmd;
    int ret;

    DBG(("cleanup(fd=%u)\n", fd));

    cmd.id     = 0;
    cmd.size   = 0;
    cmd.buffer = NULL;
    ret = ioctl(fd, TFFS_CLEANUP, &cmd);

    if(ret | cmd.status) {
        DBG(("cleanup failed ret=%d status=%d\n", ret, cmd.status));
    }

    return ret | cmd.status;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
int tffs_read_value(int fd, enum _tffs_id id, void *buffer, unsigned int size) {
    struct _tffs_cmd cmd;
    int ret;

    DBG(("read_value(fd=%u, id=0x%x, buffer, %u bytes)\n", fd, id, size));

    cmd.id     = (enum _tffs_id)id;
    cmd.size   = size;
    cmd.buffer = buffer;
    ret = ioctl(fd, TFFS_READ_ID, &cmd);

    if((ret < 0) || cmd.status) {
        DBG(("read_value failed ret=%d status=%d\n", ret, cmd.status));
        return 0;
    } 
    DBG(("*Buffer: 0x%08x\n", *(unsigned int *)buffer));
    return cmd.size;
}

/*------------------------------------------------------------------------------------------*\
\*------------------------------------------------------------------------------------------*/
int tffs_write_value(int fd, enum _tffs_id id, void *buffer, unsigned int size) {
    struct _tffs_cmd cmd;
    int ret;

    DBG(("write_value(fd=%u, id=0x%x, buffer, %u bytes)\n", fd, id, size));
    /*--- DBG(("*Buffer: 0x%08x\n", *(unsigned int *)buffer)); ---*/

    cmd.id     = (enum _tffs_id)id;
    cmd.size   = size;
    cmd.buffer = buffer;
    ret = ioctl(fd, TFFS_WRITE_ID, &cmd);

    if((ret < 0) || cmd.status) {
        DBG(("write_value failed ret=%d status=%d\n", ret, cmd.status));
        return 0;
    }
    return cmd.size;
}