Subversion Repositories darkriscv

/*
 * Copyright (c) 2018, Marcelo Samsoniuk
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * 
 * * Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * 
 * * Neither the name of the copyright holder nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */
 
#include <io.h>
#include <stdio.h>
#include <stdarg.h>
 
#ifdef __RISCV__
 
// idle time, update timer and blink the led! :)
 
void _idle(void)
{
    if(io.irq&IRQ_TIMR)
    {
      if(!utimers--)
      {
        io.led++;
        utimers=999999;
      }
      io.irq = IRQ_TIMR;
    }
}
 
// putchar and getchar uses the "low-level" io
 
int getchar(void)
{
  while((io.uart.stat&2)==0) _idle(); // uart empty, wait...
  return io.uart.fifo;
}
 
int putchar(int c)
{
  if(c=='\n')
  {
    while(io.uart.stat&1) _idle(); // uart busy, wait...
    io.uart.fifo = '\r';  
  }
 
  while(io.uart.stat&1) _idle(); // uart busy, wait...
  return io.uart.fifo = c;
}
 
#endif
 
// high-level functions use the getchar/putchar
 
char *gets(char *p,int s)
{
  char *ret = p;
  int c;
 
  while(--s)
  {
    c=getchar();
 
    if(c=='\n'||c=='\r') break;
#ifdef __RISCV__     
    putchar(c);
#endif
    if(c=='\b') // backspace!
    {
        if(p!=ret) 
        {
            *--p = 0;
            s++;
        }
    }
    else
        *p++ = c;
  }
#ifdef __RISCV__
  putchar('\n');
#endif
  *p=0;
 
  return p==ret ? NULL : ret;
}
 
void putstr(char *p)
{
    if(p) while(*p) putchar(*p++);
    else putstr("(NULL)");
}
 
int puts(char *p)
{
    putstr(p);
    return putchar('\n');
}
 
void putdx(unsigned i, int mode) // mode1 = dec, mode0 = hex
{
    char *hex="0123456789abcdef";
 
    int dbd[] = { 1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1, 0 };
    int dbx[] = { 16777216, 65536, 256, 1, 0 };
 
    int *db = mode ? dbd : dbx;
 
    if(mode && i<0)
    {
        putchar('-');
        i=-1;
    }
 
    int j,k,l;
 
    for(j=0,k=24;(l=db[j]);j++,k-=8)
    {
        if(l==1 || i>=l)
        {
            if(mode)
            {
                putchar(hex[(i/l)%10]);
            }
            else
            {
                putchar(hex[(i>>(k+4))&15]);
                putchar(hex[(i>>k)&15]);
            }
        }
    }
}
 
void putx(unsigned i)
{
    putdx(i,0);
}
 
void putd(int i)
{
    putdx(i,1);
}
 
int printf(char *fmt,...)
{
    va_list ap;
 
    for(va_start(ap, fmt);*fmt;fmt++)
    {
        if(*fmt=='%')
        {
            fmt++;
                 if(*fmt=='s') putstr(va_arg(ap,char *));
            else if(*fmt=='x') putx(va_arg(ap,int));
            else if(*fmt=='d') putd(va_arg(ap,int));
            else putchar(*fmt);
        }
        else putchar(*fmt);
    }
 
    va_end(ap);
 
    return 0;
}
 
int strncmp(char *s1,char *s2,int len)
{
    while(--len && *s1 && *s2 && (*s1==*s2)) s1++, s2++;
 
    return (*s1-*s2);
}
 
int strcmp(char *s1, char *s2)
{
    return strncmp(s1,s2,-1);
}
 
int strlen(char *s1)
{
    int len;
 
    for(len=0;s1&&*s1++;len++);
 
    return len;
}
 
char *memcpy(char *dptr,char *sptr,int len)
{
    char *ret = dptr;
 
    while(len--) *dptr++ = *sptr++;
 
    return ret;
}
 
char *memset(char *dptr, int c, int len)
{
    char *ret = dptr;
 
    while(len--) *dptr++ = c;
 
    return ret;
}
 
char *strtok(char *str,char *dptr)
{
    static char *nxt = NULL;
 
    int dlen = strlen(dptr);
    char *tmp;
 
         if(str) tmp=str;
    else if(nxt) tmp=nxt;
    else return NULL;
 
    char *ret=tmp;
 
    while(*tmp)
    {
        if(strncmp(tmp,dptr,dlen)==0)
        {
            *tmp=NUL;
            nxt = tmp+1;
            return ret;
        }
        tmp++;
    }
    nxt = NULL;
    return ret;
}
 
int atoi(char *s1)
{
    int ret,sig;
 
    for(sig=ret=0;s1&&*s1;s1++) 
    {
        if(*s1=='-') 
            sig=1;
        else 
            ret = *s1-'0'+(ret<<3)+(ret<<1); // val = val*10+int(*s1)
    }
 
    return sig ? -ret : ret;
}
 
int xtoi(char *s1)
{
    int ret;
 
    for(ret=0;s1&&*s1;s1++) 
    {
        if(*s1<='9')
            ret = *s1-'0'+(ret<<4); // val = val*16+int(*s1)
        else
            ret = 10+(*s1&0x5f)-'A'+(ret<<4); // val = val*16+int(toupper(*s1))
    }
 
    return ret;
}
 
int mac(int acc,short x,short y)
{
#ifdef __RISCV__
    __asm__(".word 0x00c5857F"); // mac a0,a1,a2
    // "template"
    //acc += (x^y);
#else
    acc+=x*y;
#endif
    return acc;
}
 
unsigned __umulsi3(unsigned x,unsigned y)
{
    unsigned acc;
 
    if(x<y) { unsigned z = x; x = y; y = z; }
 
    for(acc=0;y;x<<=1,y>>=1) if (y & 1) acc += x;
 
    return acc;
}
 
int __mulsi3(int x, int y)
{
    unsigned acc,xs,ys;
 
    if(x<0) { xs=1; x=-x; } else xs=0;
    if(y<0) { ys=1; y=-y; } else ys=0;
 
    acc = __umulsi3(x,y);
 
    return xs^ys ? -acc : acc;
}
 
unsigned __udiv_umod_si3(unsigned x,unsigned y,int opt)
{
    unsigned acc,aux;
 
    if(!y) return 0;
 
    for(aux=1;y<x&&!(y&(1<<31));aux<<=1,y<<=1);
    for(acc=0;x&&aux;aux>>=1,y>>=1) if(y<=x) x-=y,acc+=aux;
 
    return opt ? acc : x;
}
 
int __udivsi3(int x, int y)
{
    return __udiv_umod_si3(x,y,1);
}
 
int __umodsi3(int x,int y)
{
    return __udiv_umod_si3(x,y,0);
}
 
int __div_mod_si3(int x,int y,int opt)
{
    unsigned acc,xs,ys;
 
    if(!y) return 0;
 
    if(x<0) { xs=1; x=-x; } else xs=0;
    if(y<0) { ys=1; y=-y; } else ys=0;
 
    acc = __udiv_umod_si3(x,y,opt);
 
    if(opt) return xs^ys ? -acc : acc;
    else    return xs    ? -acc : acc;
}
 
int __divsi3(int x, int y)
{
    return __div_mod_si3(x,y,1);
}
 
int __modsi3(int x,int y)
{
    return __div_mod_si3(x,y,0);
}
 
void usleep(int delay)
{
    {
        while(delay--) 
        {
            for(io.irq=IRQ_TIMR;!io.irq;);
        }
    }
}