Subversion Repositories openarty

////////////////////////////////////////////////////////////////////////////////

//

// Filename:    syscalls.c

//

// Project:     Zip CPU -- a small, lightweight, RISC CPU soft core

//

// Purpose:     

//

//

// Creator:     Dan Gisselquist, Ph.D.

//              Gisselquist Technology, LLC

//

////////////////////////////////////////////////////////////////////////////////

//

// Copyright (C) 2015-2016, Gisselquist Technology, LLC

//

// This program is free software (firmware): you can redistribute it and/or

// modify it under the terms of  the GNU General Public License as published

// by the Free Software Foundation, either version 3 of the License, or (at

// your option) any later version.

//

// This program is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// License:     GPL, v3, as defined and found on www.gnu.org,

//              http://www.gnu.org/licenses/gpl.html

//

//

////////////////////////////////////////////////////////////////////////////////

//

//

#include <sys/errno.h>

#include <stdint.h>

#include <sys/unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/times.h>

#include <reent.h>

#include <stdio.h>

#include "artyboard.h"

#include "bootloader.h"

#include "zipcpu.h"

void

_outbyte(char v) {

#ifdef  _ZIP_HAS_WBUART

        if (v == '\n') {

                // Depend upon the WBUART, not the PIC

                while(_uart->u_fifo & 0x010000)

                        ;

                _uarttx = (unsigned)'\r';

        }

        // Depend upon the WBUART, not the PIC

        while(_uart->u_fifo & 0x010000)

                ;

        uint8_t c = v;

        _uarttx = (unsigned)c;

#else

#ifdef  _ZIP_HAS_UARTTX

        // Depend upon the WBUART, not the PIC

        while(UARTTX & 0x100)

                ;

        uint8_t c = v;

        UARTTX = (unsigned)c;

#endif

#endif

}

int

_inbyte(void) {

#ifdef  _ZIP_HAS_WBUARTRX

        const   int     echo = 1, cr_into_nl = 1;

        static  int     last_was_cr = 0;

        int     rv;

        // Character translations:

        // 1. All characters should be echoed

        // 2. \r's should quietly be turned into \n's

        // 3. \r\n's should quietly be turned into \n's

        // 4. \n's should be passed as is

        // Insist on at least one character

        rv = _uartrx;

        if (rv & 0x0100)

                rv = -1;

        else if ((cr_into_nl)&&(rv == '\r')) {

                rv = '\n';

                last_was_cr = 1;

        } else if ((cr_into_nl)&&(rv == '\n')) {

                if (last_was_cr) {

                        rv = -1;

                        last_was_cr = 0;

                }

        } else

                last_was_cr = 0;

        if ((rv != -1)&&(echo))

                _outbyte(rv);

        return rv;

#else

        return -1;

#endif

}

int

_close_r(struct _reent *reent, int file) {

        reent->_errno = EBADF;

        return -1;      /* Always fails */

}

char    *__env[1] = { 0 };

char    **environ = __env;

int

_execve_r(struct _reent *reent, const char *name, char * const *argv, char * const *env)

{

        reent->_errno = ENOSYS;

        return -1;

}

int

_fork_r(struct _reent *reent)

{

        reent->_errno = ENOSYS;

        return -1;

}

int

_fstat_r(struct _reent *reent, int file, struct stat *st)

{

        if ((STDOUT_FILENO == file)||(STDERR_FILENO == file)

                ||(STDIN_FILENO == file)) {

                st->st_mode = S_IFCHR;

                return 0;

#ifdef  _ZIP_HAS_SDCARD_NOTYET

        } else if (SDCARD_FILENO == file) {

                st->st_mode = S_IFBLK;

#endif

        } else {

                reent->_errno = EBADF;

                return -1;

        }

}

int

_getpid_r(struct _reent *reent)

{

        return 1;

}

int

_gettimeofday_r(struct _reent *reent, struct timeval *ptimeval, void *ptimezone)

{

#ifdef  _ZIP_HAS_RTC

        if (ptimeval) {

                uint32_t        now, date;

                unsigned        s, m, h, tod;

                now = _rtcdev->r_clock;

#ifdef  _ZIP_HAS_RTDATE

                unsigned        d, y, c, yy, days_since_epoch;

                int             ly;

                date= *_rtdate;

                d = ( date     &0x0f)+((date>> 4)&0x0f)*10;

                m = ((date>> 8)&0x0f)+((date>>12)&0x0f)*10;

                y = ((date>>16)&0x0f)+((date>>20)&0x0f)*10;

                c = ((date>>24)&0x0f)+((date>>28)&0x0f)*10;

                ly = 0;

                if ((y&3)==0) {

                        if (y!=0)

                                ly = 1;

                        else if ((y&3)==0)

                                ly = 1;

                }

                days_since_epoch = d;

                if (m>1) {

                        days_since_epoch += 31;

                        if (m>2) {

                                days_since_epoch += 28;

                                if (ly) days_since_epoch++;

                                if (m>3)  { days_since_epoch += 31;

                                if (m>4)  { days_since_epoch += 30;

                                if (m>5)  { days_since_epoch += 31;

                                if (m>6)  { days_since_epoch += 30;

                                if (m>7)  { days_since_epoch += 31;

                                if (m>8)  { days_since_epoch += 31;

                                if (m>9)  { days_since_epoch += 30;

                                if (m>10) { days_since_epoch += 31;

                                if (m>11)   days_since_epoch += 30;

                }}}}}}}}}}

                for(yy=1970; yy<(c*100+y); yy++) {

                        if ((yy&3)==0)

                                days_since_epoch += 366;

                        else

                                days_since_epoch += 365;

                }

                ptimeval->tv_sec  = days_since_epoch * 86400l;

#else

                ptimeval->tv_sec  = 0;

#endif

                s = ( now     &0x0f)+((now>> 4)&0x0f)*10;

                m = ((now>> 8)&0x0f)+((now>>12)&0x0f)*10;

                h = ((now>>16)&0x0f)+((now>>20)&0x0f)*10;

                tod = (h * 60 + m) * 60;

                ptimeval->tv_sec += tod;

                ptimeval->tv_usec = 0;

        }

        return 0;

#else

        reent->_errno = ENOSYS;

        return -1;

#endif

}

int

_isatty_r(struct _reent *reent, int file)

{

        if ((STDIN_FILENO == file)

                        ||(STDOUT_FILENO == file)

                        ||(STDERR_FILENO==file))

                return 1;

        return 0;

}

int

_kill_r(struct _reent *reent, int pid, int sig)

{

        reent->_errno = ENOSYS;

        return -1;

}

int

_link_r(struct _reent *reent, const char *existing, const char *new)

{

        reent->_errno = ENOSYS;

        return -1;

}

_off_t

_lseek_r(struct _reent *reent, int file, _off_t ptr, int dir)

{

#ifdef  _ZIP_HAS_SDCARD_NOTYET

        if (SDCARD_FILENO == file) {

                switch(dir) {

                case SEEK_SET:  rootfs_offset = ptr;

                case SEEK_CUR:  rootfs_offset += ptr;

                case SEEK_END:  rootfs_offset = rootfs->nsectors * rootfs->sectorsize - ptr;

                default:

                        reent->_errno = EINVAL; return -1;

                } return rootfs_offset;

        }

#endif

        reent->_errno = ENOSYS;

        return -1;

}

int

_open_r(struct _reent *reent, const char *file, int flags, int mode)

{

#ifdef  _ZIP_HAS_SDCARD_NOTYET

        if (strcmp(file, "/dev/sdcard")==0) {

                return SDCARD_FILENO;

        } else {

                reent->_errno = EACCES;

                return -1;

        }

#endif

        reent->_errno = ENOSYS;

        return -1;

}

int

_read_r(struct _reent *reent, int file, void *ptr, size_t len)

{

#ifdef  _ZIP_HAS_WBUARTRX

        if (STDIN_FILENO == file)

        {

                int     nr = 0, rv;

                char    *chp = ptr;

                while((rv=_inbyte()) &0x0100)

                        ;

                *chp++ = (char)rv;

                nr++;

                // Now read out anything left in the FIFO

                while((nr < len)&&(((rv=_inbyte()) & 0x0100)==0)) {

                        *chp++ = (char)rv;

                        nr++;

                }

                // if (rv & 0x01000) _uartrx = 0x01000;

                return nr;

        }

#endif

#ifdef  _ZIP_HAS_SDCARD_NOTYET

        if (SDCARD_FILENO == file)

        {

        }

#endif

        errno = ENOSYS;

        return -1;

}

int

_readlink_r(struct _reent *reent, const char *path, char *buf, size_t bufsize)

{

        reent->_errno = ENOSYS;

        return -1;

}

int

_stat_r(struct _reent *reent, const char *path, struct stat *buf) {

        reent->_errno = EIO;

        return -1;

}

int

_unlink_r(struct _reent *reent, const char *path)

{

        reent->_errno = EIO;

        return -1;

}

int

_times(struct tms *buf) {

        errno = EACCES;

        return -1;

}

int

_write_r(struct _reent * reent, int fd, const void *buf, size_t nbytes) {

        if ((STDOUT_FILENO == fd)||(STDERR_FILENO == fd)) {

                const   char *cbuf = buf;

                for(int i=0; i<nbytes; i++)

                        _outbyte(cbuf[i]);

                return nbytes;

        }

#ifdef  _ZIP_HAS_SDCARD_NOTYET

        if (SDCARD_FILENO == file)

        {

        }

#endif

        reent->_errno = EBADF;

        return -1;

}

int

_wait(int *status) {

        errno = ECHILD;

        return -1;

}

int     *heap = _top_of_heap;

void *

_sbrk_r(struct _reent *reent, int sz) {

        int     *prev = heap;

        heap += sz;

        return  prev;

}