Subversion Repositories neorv32

/* An extremely minimalist syscalls.c for newlib

 * Based on riscv newlib libgloss/riscv/sys_*.c

 *

 * Copyright 2019 Clifford Wolf

 * Copyright 2019 ETH Zürich and University of Bologna

 *

 * Permission to use, copy, modify, and/or distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH

 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY

 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,

 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM

 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR

 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

 * PERFORMANCE OF THIS SOFTWARE.

 */

/**********************************************************************//**

 * @file syscalls.c

 * @brief Newlib system calls

 *

 * @warning UART0 (if available) is used to read/write console data (STDIN, STDOUT, STDERR, ...).

 *

 * @note Original source file: https://github.com/openhwgroup/cv32e40p/blob/master/example_tb/core/custom/syscalls.c

 * @note Original license: SOLDERPAD HARDWARE LICENSE version 0.51

 * @note More information was derived from: https://interrupt.memfault.com/blog/boostrapping-libc-with-newlib#implementing-newlib

 **************************************************************************/

#include <sys/stat.h>

#include <sys/timeb.h>

#include <sys/times.h>

#include <utime.h>

#include <newlib.h>

#include <unistd.h>

#include <errno.h>

#include <neorv32.h>

#undef errno

extern int errno;

// defined in sw/common/crt0.S

extern const volatile unsigned int __crt0_main_exit;

/* It turns out that older newlib versions use different symbol names which goes

 * against newlib recommendations. Anyway this is fixed in later version.

 */

#if __NEWLIB__ <= 2 && __NEWLIB_MINOR__ <= 5

#    define _sbrk sbrk

#    define _write write

#    define _close close

#    define _lseek lseek

#    define _read read

#    define _fstat fstat

#    define _isatty isatty

#endif

void unimplemented_syscall()

{

  if (neorv32_uart0_available()) {

    neorv32_uart0_print("<syscalls.c> Unimplemented system call called!\n");

  }

}

int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)

{

    errno = ENOSYS;

    return -1;

}

int _access(const char *file, int mode)

{

    errno = ENOSYS;

    return -1;

}

int _chdir(const char *path)

{

    errno = ENOSYS;

    return -1;

}

int _chmod(const char *path, mode_t mode)

{

    errno = ENOSYS;

    return -1;

}

int _chown(const char *path, uid_t owner, gid_t group)

{

    errno = ENOSYS;

    return -1;

}

int _close(int file)

{

    return -1;

}

int _execve(const char *name, char *const argv[], char *const env[])

{

    errno = ENOMEM;

    return -1;

}

void _exit(int exit_status)

{

    // jump to crt0's shutdown code

    asm volatile ("la t0, __crt0_main_exit \n"

                  "jr t0                   \n");

    while(1); // will never be reached

}

int _faccessat(int dirfd, const char *file, int mode, int flags)

{

    errno = ENOSYS;

    return -1;

}

int _fork(void)

{

    errno = EAGAIN;

    return -1;

}

int _fstat(int file, struct stat *st)

{

    st->st_mode = S_IFCHR; // all files are "character special files"

    return 0;

}

int _fstatat(int dirfd, const char *file, struct stat *st, int flags)

{

    errno = ENOSYS;

    return -1;

}

int _ftime(struct timeb *tp)

{

    errno = ENOSYS;

    return -1;

}

char *_getcwd(char *buf, size_t size)

{

    errno = -ENOSYS;

    return NULL;

}

int _getpid()

{

    return 1;

}

int _gettimeofday(struct timeval *tp, void *tzp)

{

    errno = -ENOSYS;

    return -1;

}

int _isatty(int file)

{

    return (file == STDOUT_FILENO);

}

int _kill(int pid, int sig)

{

    errno = EINVAL;

    return -1;

}

int _link(const char *old_name, const char *new_name)

{

    errno = EMLINK;

    return -1;

}

off_t _lseek(int file, off_t ptr, int dir)

{

    return 0;

}

int _lstat(const char *file, struct stat *st)

{

    errno = ENOSYS;

    return -1;

}

int _open(const char *name, int flags, int mode)

{

    return -1;

}

int _openat(int dirfd, const char *name, int flags, int mode)

{

    errno = ENOSYS;

    return -1;

}

ssize_t _read(int file, void *ptr, size_t len)

{

    int read_cnt = 0;

    // read everything (STDIN, ...) from NEORV32.UART0 (if available)

    if (neorv32_uart0_available()) {

      char *char_ptr;

      char_ptr = (char *)ptr;

      while (len > 0) {

        *char_ptr++ = (char)neorv32_uart0_getc();

        read_cnt++;

        len--;

      }

    }

    return read_cnt;

}

int _stat(const char *file, struct stat *st)

{

    st->st_mode = S_IFCHR;

    return 0;

    // errno = ENOSYS;

    // return -1;

}

long _sysconf(int name)

{

    return -1;

}

clock_t _times(struct tms *buf)

{

    return -1;

}

int _unlink(const char *name)

{

    errno = ENOENT;

    return -1;

}

int _utime(const char *path, const struct utimbuf *times)

{

    errno = ENOSYS;

    return -1;

}

int _wait(int *status)

{

    errno = ECHILD;

    return -1;

}

ssize_t _write(int file, const void *ptr, size_t len)

{

    // write everything (STDOUT, STDERR, ...) to NEORV32.UART0 (if available)

    const void *eptr = ptr + len;

    if (neorv32_uart0_available()) {

      while (ptr != eptr) {

        neorv32_uart0_putc(*(char *)(ptr++));

      }

      return len;

    }

    else {

      return (size_t)0; // nothing sent

    }

}

extern char __heap_start[];

extern char __heap_end[];

static char *brk = __heap_start;

int _brk(void *addr)

{

    brk = addr;

    return 0;

}

void *_sbrk(ptrdiff_t incr)

{

    char *old_brk = brk;

    if (__heap_start == __heap_end) {

        return NULL;

    }

    if ((brk += incr) < __heap_end) {

        brk += incr;

    } else {

        brk = __heap_end;

    }

    return old_brk;

}