Stripped-down version with icosoc routines

Version now is below 128k but doesn't include most application-specific
interesting stuff.
The icosoc routines for I/O are now linked in (thanks to Clifford for
spotting this) and we have debug output.
Current code is enough to get cooperative multitasking and timers
working and tested, this is next todo.
This commit is contained in:
Ralf Schlatterbeck 2016-04-01 18:26:59 +02:00
parent 57959a53f6
commit c49d4a0b36
5 changed files with 587 additions and 19 deletions

View file

@ -0,0 +1,8 @@
icosoc.asc
icosoc.blif
icosoc.mk
icosoc.pcf
icosoc.v
icosoc.ys
wallclock.co
wallclock.pico-rv32-icoboard

View file

@ -17,13 +17,14 @@ CONTIKI=../../..
CFLAGS += -DPROJECT_CONF_H=\"project-conf.h\"
PROJECTDIRS += $(REST_RESOURCES_DIR) $(REST_RESOURCES_DIR_COMMON)
PROJECT_SOURCEFILES += $(REST_RESOURCES_FILES)
#FIXME PROJECTDIRS += $(REST_RESOURCES_DIR) $(REST_RESOURCES_DIR_COMMON)
#FIXME PROJECT_SOURCEFILES += $(REST_RESOURCES_FILES)
PROJECT_SOURCEFILES += icosoc.c
# REST Engine shall use Erbium CoAP implementation
APPS += er-coap
APPS += rest-engine
APPS += json json-resource time
#FIXME APPS += er-coap
#FIXME APPS += rest-engine
#FIXME APPS += json json-resource time
CONTIKI_WITH_IPV6 = 1
include $(CONTIKI)/Makefile.include

View file

@ -0,0 +1,528 @@
// #### This file is auto-generated from icosoc.py. Do not edit! ####
#include "icosoc.h"
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
void icosoc_ser0_read(void *data, int len)
{
while (len > 0) {
int n = icosoc_ser0_read_nb(data, len);
data += n, len -= n;
}
}
void icosoc_ser0_write(const void *data, int len)
{
while (len > 0) {
int n = icosoc_ser0_write_nb(data, len);
data += n, len -= n;
}
}
int icosoc_ser0_read_nb(void *data, int maxlen)
{
uint8_t *p = data;
int len = *(volatile uint32_t*)(0x20000004 + 1 * 0x10000);
if (len > maxlen) len = maxlen;
for (int i = 0; i < len; i++)
p[i] = *(volatile uint32_t*)(0x20000000 + 1 * 0x10000);
return len;
}
int icosoc_ser0_write_nb(const void *data, int maxlen)
{
const uint8_t *p = data;
int len = *(volatile uint32_t*)(0x20000008 + 1 * 0x10000);
if (len > maxlen) len = maxlen;
for (int i = 0; i < len; i++)
*(volatile uint32_t*)(0x20000000 + 1 * 0x10000) = p[i];
return len;
}
// Based on riscv newlib libgloss/riscv/machine/syscall.h
// Changes by Clifford Wolf
//========================================================================
// syscalls.c : Newlib operating system interface
//========================================================================
// This is the maven implementation of the narrow newlib operating
// system interface. It is based on the minimum stubs in the newlib
// documentation, the error stubs in libnosys, and the previous scale
// implementation. Please do not include any additional system calls or
// other functions in this file. Additional header and source files
// should be in the machine subdirectory.
//
// Here is a list of the functions which make up the operating system
// interface. The file management instructions execute syscall assembly
// instructions so that a proxy kernel (or the simulator) can marshal up
// the request to the host machine. The process management functions are
// mainly just stubs since for now maven only supports a single process.
//
// - File management functions
// + open : (v) open file
// + lseek : (v) set position in file
// + read : (v) read from file
// + write : (v) write to file
// + fstat : (z) status of an open file
// + stat : (z) status of a file by name
// + close : (z) close a file
// + link : (z) rename a file
// + unlink : (z) remote file's directory entry
//
// - Process management functions
// + execve : (z) transfer control to new proc
// + fork : (z) create a new process
// + getpid : (v) get process id
// + kill : (z) send signal to child process
// + wait : (z) wait for a child process
//
// - Misc functions
// + isatty : (v) query whether output stream is a terminal
// + times : (z) timing information for current process
// + sbrk : (v) increase program data space
// + _exit : (-) exit program without cleaning up files
//
// There are two types of system calls. Those which return a value when
// everything is okay (marked with (v) in above list) and those which
// return a zero when everything is okay (marked with (z) in above
// list). On an error (ie. when the error flag is 1) the return value is
// always an errno which should correspond to the numbers in
// newlib/libc/include/sys/errno.h
//
// Note that really I think we are supposed to define versions of these
// functions with an underscore prefix (eg. _open). This is what some of
// the newlib documentation says, and all the newlib code calls the
// underscore version. This is because technically I don't think we are
// supposed to pollute the namespace with these function names. If you
// define MISSING_SYSCALL_NAMES in xcc/src/newlib/configure.host
// then xcc/src/newlib/libc/include/_syslist.h will essentially define
// all of the underscore versions to be equal to the non-underscore
// versions. I tried not defining MISSING_SYSCALL_NAMES, and newlib
// compiled fine but libstdc++ complained about not being able to fine
// write, read, etc. So for now we do not use underscores (and we do
// define MISSING_SYSCALL_NAMES).
//
// See the newlib documentation for more information
// http://sourceware.org/newlib/libc.html#Syscalls
#include <sys/stat.h>
#include <sys/times.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <utime.h>
//------------------------------------------------------------------------
// environment
//------------------------------------------------------------------------
// A pointer to a list of environment variables and their values. For a
// minimal environment, this empty list is adequate. We used to define
// environ here but it is already defined in
// xcc/src/newlib/libc/stdlib/environ.c so to avoid multiple definition
// errors we have commented this out for now.
//
// char* __env[1] = { 0 };
// char** environ = __env;
//------------------------------------------------------------------------
// open
//------------------------------------------------------------------------
// Open a file.
int open(const char* name, int flags, int mode)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// openat
//------------------------------------------------------------------------
// Open file relative to given directory
int openat(int dirfd, const char* name, int flags, int mode)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// lseek
//------------------------------------------------------------------------
// Set position in a file.
off_t lseek(int file, off_t ptr, int dir)
{
errno = ESPIPE;
return -1;
}
//----------------------------------------------------------------------
// read
//----------------------------------------------------------------------
// Read from a file.
ssize_t read(int file, void *ptr, size_t len)
{
// All reads read from console
unsigned char *p = ptr;
for (int i = 0; i < len;) {
int v = *(volatile int*)0x30000000;
if (v >= 0)
p[i++] = v;
else if (i)
return i;
}
return len;
}
//------------------------------------------------------------------------
// write
//------------------------------------------------------------------------
// Write to a file.
ssize_t write(int file, const void *ptr, size_t len)
{
// All writes go to console
const unsigned char *p = ptr;
for (int i = 0; i < len; i++)
*(volatile int*)0x30000000 = p[i];
return len;
}
//------------------------------------------------------------------------
// fstat
//------------------------------------------------------------------------
// Status of an open file. The sys/stat.h header file required is
// distributed in the include subdirectory for this C library.
int fstat(int file, struct stat *st)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// stat
//------------------------------------------------------------------------
// Status of a file (by name).
int stat(const char *file, struct stat *st)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// lstat
//------------------------------------------------------------------------
// Status of a link (by name).
int lstat(const char *file, struct stat *st)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// fstatat
//------------------------------------------------------------------------
// Status of a file (by name) in a given directory.
int fstatat(int dirfd, const char *file, struct stat *st, int flags)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// access
//------------------------------------------------------------------------
// Permissions of a file (by name).
int access(const char *file, int mode)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// faccessat
//------------------------------------------------------------------------
// Permissions of a file (by name) in a given directory.
int faccessat(int dirfd, const char *file, int mode, int flags)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// close
//------------------------------------------------------------------------
// Close a file.
int close(int file)
{
// close is always ok
return 0;
}
//------------------------------------------------------------------------
// link
//------------------------------------------------------------------------
// Establish a new name for an existing file.
int link(const char *old_name, const char *new_name)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// unlink
//------------------------------------------------------------------------
// Remove a file's directory entry.
int unlink(const char *name)
{
errno = ENOENT;
return -1;
}
//------------------------------------------------------------------------
// execve
//------------------------------------------------------------------------
// Transfer control to a new process. Minimal implementation for a
// system without processes from newlib documentation.
int execve(const char *name, char *const argv[], char *const env[])
{
errno = ENOMEM;
return -1;
}
//------------------------------------------------------------------------
// fork
//------------------------------------------------------------------------
// Create a new process. Minimal implementation for a system without
// processes from newlib documentation.
int fork()
{
errno = EAGAIN;
return -1;
}
//------------------------------------------------------------------------
// getpid
//------------------------------------------------------------------------
// Get process id. This is sometimes used to generate strings unlikely
// to conflict with other processes. Minimal implementation for a
// system without processes just returns 1.
int getpid()
{
return 1;
}
//------------------------------------------------------------------------
// kill
//------------------------------------------------------------------------
// Send a signal. Minimal implementation for a system without processes
// just causes an error.
int kill(int pid, int sig)
{
errno = EINVAL;
return -1;
}
//------------------------------------------------------------------------
// wait
//------------------------------------------------------------------------
// Wait for a child process. Minimal implementation for a system without
// processes just causes an error.
int wait(int *status)
{
errno = ECHILD;
return -1;
}
//------------------------------------------------------------------------
// isatty
//------------------------------------------------------------------------
// Query whether output stream is a terminal. For consistency with the
// other minimal implementations, which only support output to stdout,
// this minimal implementation is suggested by the newlib docs.
int isatty(int file)
{
return 1;
}
//------------------------------------------------------------------------
// times
//------------------------------------------------------------------------
// Timing information for current process. From
// newlib/libc/include/sys/times.h the tms struct fields are as follows:
//
// - clock_t tms_utime : user clock ticks
// - clock_t tms_stime : system clock ticks
// - clock_t tms_cutime : children's user clock ticks
// - clock_t tms_cstime : children's system clock ticks
//
// Since maven does not currently support processes we set both of the
// children's times to zero. Eventually we might want to separately
// account for user vs system time, but for now we just return the total
// number of cycles since starting the program.
clock_t times(struct tms *buf)
{
// when called for the first time, initialize t0
static struct timeval t0;
if (t0.tv_sec == 0)
gettimeofday(&t0, 0);
struct timeval t;
gettimeofday(&t, 0);
long long utime = (t.tv_sec - t0.tv_sec) * 1000000 + (t.tv_usec - t0.tv_usec);
buf->tms_utime = utime * CLOCKS_PER_SEC / 1000000;
buf->tms_stime = buf->tms_cstime = buf->tms_cutime = 0;
return -1;
}
//----------------------------------------------------------------------
// gettimeofday
//----------------------------------------------------------------------
// Get the current time. Only relatively correct.
int gettimeofday(struct timeval *tp, void *tzp)
{
asm volatile ("sbreak");
__builtin_unreachable();
}
//----------------------------------------------------------------------
// ftime
//----------------------------------------------------------------------
// Get the current time. Only relatively correct.
int ftime(struct timeb *tp)
{
tp->time = tp->millitm = 0;
return 0;
}
//----------------------------------------------------------------------
// utime
//----------------------------------------------------------------------
// Stub.
int utime(const char *path, const struct utimbuf *times)
{
return -1;
}
//----------------------------------------------------------------------
// chown
//----------------------------------------------------------------------
// Stub.
int chown(const char *path, uid_t owner, gid_t group)
{
return -1;
}
//----------------------------------------------------------------------
// chmod
//----------------------------------------------------------------------
// Stub.
int chmod(const char *path, mode_t mode)
{
return -1;
}
//----------------------------------------------------------------------
// chdir
//----------------------------------------------------------------------
// Stub.
int chdir(const char *path)
{
return -1;
}
//----------------------------------------------------------------------
// getcwd
//----------------------------------------------------------------------
// Stub.
char *getcwd(char *buf, size_t size)
{
return NULL;
}
//----------------------------------------------------------------------
// sysconf
//----------------------------------------------------------------------
// Get configurable system variables
long sysconf(int name)
{
switch (name) {
case _SC_CLK_TCK:
return CLOCKS_PER_SEC;
}
return -1;
}
//----------------------------------------------------------------------
// sbrk
//----------------------------------------------------------------------
// Increase program data space. As malloc and related functions depend
// on this, it is useful to have a working implementation. The following
// is suggested by the newlib docs and suffices for a standalone
// system.
void *sbrk(ptrdiff_t incr)
{
extern unsigned char _end[]; // Defined by linker
static unsigned long heap_end;
if (heap_end == 0)
heap_end = (long)_end;
// if (syscall_errno(SYS_brk, heap_end + incr, 0, 0, 0) != heap_end + incr)
// return (void *)-1;
heap_end += incr;
return (void *)(heap_end - incr);
}
//------------------------------------------------------------------------
// _exit
//------------------------------------------------------------------------
// Exit a program without cleaning up files.
void _exit(int exit_status)
{
asm volatile ("sbreak");
__builtin_unreachable();
}

View file

@ -0,0 +1,30 @@
// #### This file is auto-generated from icosoc.py. Do not edit! ####
#ifndef ICOSOC_H
#define ICOSOC_H
#define ICOSOC_CLOCK_FREQ_HZ 6000000
void icosoc_ser0_read(void *data, int len);
void icosoc_ser0_write(const void *data, int len);
int icosoc_ser0_read_nb(void *data, int maxlen);
int icosoc_ser0_write_nb(const void *data, int maxlen);
#include <stdint.h>
static inline void icosoc_leds_set(uint32_t bitmask) {
*(volatile uint32_t*)(0x20000000 + 2 * 0x10000) = bitmask;
}
static inline uint32_t icosoc_leds_get() {
return *(volatile uint32_t*)(0x20000000 + 2 * 0x10000);
}
static inline void icosoc_leds_dir(uint32_t bitmask) {
*(volatile uint32_t*)(0x20000004 + 2 * 0x10000) = bitmask;
}
#endif /* ICOSOC_H */

View file

@ -42,11 +42,11 @@
#include <string.h>
#include "contiki.h"
#include "contiki-net.h"
#include "er-coap-engine.h"
#include "time.h"
#include "cron.h"
#include "time_resource.h"
#include "jsonparse.h"
//FIXME#include "er-coap-engine.h"
//FIXME#include "time.h"
//FIXME#include "cron.h"
//FIXME#include "time_resource.h"
//FIXME#include "jsonparse.h"
#include "icosoc.h"
#define DEBUG 0
@ -105,19 +105,19 @@ PROCESS_THREAD(wallclock, ev, data)
/* Initialize the Hardware. */
hw_init ();
/* Initialize the REST engine. */
rest_init_engine ();
//FIXME rest_init_engine ();
rest_activate_resource (&res_timestamp, "clock/timestamp");
rest_activate_resource (&res_timezone, "clock/timezone");
rest_activate_resource (&res_localtime, "clock/localtime");
rest_activate_resource (&res_utc, "clock/utc");
//FIXME rest_activate_resource (&res_timestamp, "clock/timestamp");
//FIXME rest_activate_resource (&res_timezone, "clock/timezone");
//FIXME rest_activate_resource (&res_localtime, "clock/localtime");
//FIXME rest_activate_resource (&res_utc, "clock/utc");
/* Register callback function(s) */
cron_register_command ("led_on", led_set, (void *)1);
cron_register_command ("led_off", led_set, (void *)0);
//FIXME cron_register_command ("led_on", led_set, (void *)1);
//FIXME cron_register_command ("led_off", led_set, (void *)0);
/* Allocate all cron entries and the necessary resources */
activate_cron_resources ();
//FIXME activate_cron_resources ();
/* Define application-specific events here.
* We need to call cron every 30 seconds or so (at least once a
@ -125,9 +125,10 @@ PROCESS_THREAD(wallclock, ev, data)
*/
etimer_set (&loop_periodic_timer, LOOP_INTERVAL);
while (1) {
printf ("In while loop\n");
PROCESS_WAIT_EVENT();
if (etimer_expired (&loop_periodic_timer)) {
cron ();
//cron ();
etimer_reset (&loop_periodic_timer);
}
} /* while (1) */