retarget_semihosting.c

Go to the documentation of this file.

/************************************************************************//**
 * \file    heivs/retarget_semihosting.c
 * \author  marc dot pignat at hevs dot ch
 *
 * \defgroup stdio_redir stdio redirection
 * \ingroup stdio_h
 * @{
 *
 * \brief stdio redirection for newlib
 *
 * Here is the low-level part of stdio (printf/scanf, puts, getc, ...) functions
 *
 * \see ARM DUI 0203J for the specification
 *
 ***************************************************************************/

#include "heivs/config.h"
#if !defined(USE_STDIO_USART)

#include "heivs/retarget.h"
#include "heivs/stm32_usart.h"
#include "heivs/config.h"
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

static uint32_t use_stdio_nobuf = USE_STDIO_NOBUF;
static uint32_t use_stdio_echo = USE_STDIO_ECHO;

void retarget_init(void)
{
    if (use_stdio_nobuf)
    {
        setvbuf(stdout, NULL, _IONBF, 0);
    }
}

/**
 * \brief Semihosting communication
 * \param syscall the semihosting system call
 * \param *param the parameter
 *
 */
static inline uint32_t _semi(uint32_t syscall, void *param)
{
    uint32_t result;

    if (!debugger_is_connected())
    {
        return -1;
    }

    asm volatile
    (
        // Set the syscall # in r0
        "mov r0, %1\n"

        // Set the parameter in r1
        "mov r1, %2\n"

        // Call the debugger
        "bkpt 0xab\n"

        // Get the result of the operation
        "mov %0, r0\n"
        // Output
        : "=r" (result)

        // Input
        : "r" (syscall), "r" (param)

        // Clobbers (list of modified registers + memory + flags)
        : "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc"
  );

  return result;
}

enum semi_syscalls_e
{
    SEMI_SYS_WRITE      = 0x05,
    SEMI_SYS_WRITEC     = 0x03,
    SEMI_SYS_WRITE0     = 0x04,
    SEMI_SYS_READC      = 0x07,
    SEMI_SYS_READ       = 0x06,
    SEMI_SYS_OPEN       = 0x01,
    SEMI_SYS_CLOSE      = 0x02,
    SEMI_SYS_SEEK       = 0x0a,
    SEMI_SYS_FLEN       = 0x0c,
};

struct semi_3_params
{
    uint32_t    w1;
    uint32_t    w2;
    uint32_t    w3;
};

struct semi_2_params
{
    uint32_t    w1;
    uint32_t    w2;
};

static int semi_write(int fd, const void *ptr, size_t len)
{
    struct semi_3_params params =
    {
        .w1 = fd,
        .w2 = (uint32_t)ptr,
        .w3 = len,
    };

    return _semi(SEMI_SYS_WRITE, &params);
}

static int semi_read(int fd, void *ptr, size_t len)
{
    struct semi_3_params params =
    {
        .w1 = fd,
        .w2 = (uint32_t)ptr,
        .w3 = len,
    };

    int status = _semi(SEMI_SYS_READ, &params);

    /* status ok ? */
    if (status == 0)
    {
        return len;
    }

    /* EOF ? */
    if (status == len)
    {
        return 0;
    }

    /* Partial read */
    return status;
}

int _open(const char *pathname, int flags)
{
    /**
     * Convert from flags to ARM semihosting mode
     *
     * only use binary file access
     */

    flags &= ~_FBINARY;

    uint32_t mode;
    switch (flags)
    {
        case O_RDONLY:
            /* rb */
            mode = 1;
        break;

        case O_WRONLY|O_CREAT|O_TRUNC:
            /* wb */
            mode = 5;
        break;

        case O_WRONLY|O_CREAT|O_APPEND:
            /* ab */
            mode = 9;
        break;

        case O_RDWR:
            /* rb+ */
            mode = 3;
        break;

        case O_RDWR|O_CREAT|O_TRUNC:
            /* wb+ */
            mode = 7;
        break;

        case O_RDWR|O_CREAT|O_APPEND:
            /* ab+ */
            mode = 11;
        break;

        default:
            return -EINVAL;
        break;
    }

    struct semi_3_params params =
    {
        .w1 = (uint32_t)pathname,
        .w2 = mode,
        .w3 = strlen(pathname),
    };

    return _semi(SEMI_SYS_OPEN, &params);
}

int _close(int fd)
{
    return _semi(SEMI_SYS_CLOSE, &fd);
}

int _lseek(int fd, long offset, int whence)
{
    switch (whence)
    {
    case SEEK_SET:
    break;

    case SEEK_CUR:
        return -EINVAL;
    break;

    case SEEK_END:
        return -EINVAL;
    break;

    default:
        return -EINVAL;
    }

    struct semi_3_params params =
    {
        .w1 = fd,
        .w2 = offset,
    };

    return _semi(SEMI_SYS_SEEK, &params);
}

int _fstat(int fd, struct stat *sbuf)
{
    memset(sbuf, 0x0, sizeof(*sbuf));
    sbuf->st_size = _semi(SEMI_SYS_FLEN, &fd);

    if (sbuf->st_size < 0)
    {
        sbuf->st_size = 0;
        return -1;
    }

    return 0;
}

int _write(int fd, const char *ptr, size_t len)
{
    const uint32_t auto_crlf =  USE_STDIO_AUTO_CR_BEFORE_LF;

    int i;

    if ( (fd == STDOUT_FILENO || fd == STDERR_FILENO) && auto_crlf)
    {
        for (i = 0 ; i < len ; i++)
        {
            char c = ptr[i];

            if (c == '\n')
            {
                char cr = '\r';
                _semi(SEMI_SYS_WRITEC, &cr);
            }
            _semi(SEMI_SYS_WRITEC, &c);
        }
    }
    else
    {
        semi_write(fd, ptr, len);
    }

    return len;
}

int _read(int fd, char *ptr, int len)
{
    int result;
    if (fd == STDIN_FILENO)
    {
        *ptr = _semi(SEMI_SYS_READC, NULL);
        if (use_stdio_echo)
        {
            _write(STDOUT_FILENO, ptr, 1);
        }
        return 1;
    }

    result = semi_read(fd, ptr, len);

    return result;
}

void _ttywrch(int ci)
{
    char c = ci;
    _write(STDOUT_FILENO, &c, 1);
}

#endif /* !defined(USE_STDIO_USART) */

/************************************************************************//**
 * @}
 ***************************************************************************/