integration of MetalSVM features into LwIP

- setting LwIP macro NO_SYS to 0
- this approach based on Carl-Benedikt Krueger's LwIP branch "krueger"

lwip/src/arch/sys_arch.c

@@ -24,9 +24,13 @@
 #include "lwip/opt.h"
 #include "lwip/stats.h"
 
-void sys_init(void)
-{
-}
+#ifndef TRUE
+#define TRUE	1
+#endif
+
+#ifndef FALSE
+#define FALSE	0
+#endif
 
 /** Returns the current time in milliseconds,
  * may be the same as sys_jiffies or at least based on it. */
@@ -41,3 +45,209 @@ sys_jiffies(void)
 {
   return (get_clock_tick() / TIMER_FREQ) * 1000;
 }
+
+#if !NO_SYS
+
+/* sys_init(): init needed system resources
+ * Note: At the moment there are none
+ */
+void
+sys_init(void)
+{
+}
+
+/**
+ * Sleep for some ms. Timeouts are NOT processed while sleeping.
+ *
+ * @param ms number of milliseconds to sleep
+ */
+void
+sys_msleep(u32_t ms)
+{
+  if (ms > 0) {
+    sys_sem_t delaysem;
+    err_t err = sys_sem_new(&delaysem, 0);
+    if (err == ERR_OK) {
+      sys_arch_sem_wait(&delaysem, ms);
+      sys_sem_free(&delaysem);
+    }
+  }
+}
+
+/* sys_thread_new(): Spawns a new thread with given attributes as supportet
+ * Note: In MetalSVM this is realized as kernel tasks
+ */
+sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
+{
+	tid_t	tmp;
+	create_kernel_task(&tmp,thread,arg);
+	return tmp;
+}
+
+/* sys_sem_free(): destroy's given semaphore
+ * and releases system resources.
+ * This semaphore also gets invalid.
+ */
+void sys_sem_free(sys_sem_t* sem)
+{
+	sem->valid = FALSE;
+	sem_destroy(&sem->sem);
+}
+
+/* sys_sem_valid(): returns if semaphore is valid 
+ * at the moment
+ */
+int sys_sem_valid(sys_sem_t* sem)
+{
+	return sem->valid;
+}
+
+/* sys_sem_new(): creates a new semaphre with given count.
+ * This semaphore becomes valid
+ */
+err_t sys_sem_new(sys_sem_t* sem,u8_t count)
+{
+	sem->valid = TRUE;
+	return sem_init(&sem->sem,count);
+}
+
+/* sys_sem_set_invalid(): this semapohore becomes invalid
+ * Note: this does not mean it is destroyed
+ */
+void sys_sem_set_invalid(sys_sem_t * sem)
+{
+	sem->valid = FALSE;
+}
+
+/* sys_sem_signal(): this semaphore is signaled
+ *
+ */
+void sys_sem_signal(sys_sem_t* sem)
+{
+	sem_post(&sem->sem);
+}
+
+/* sys_arch_sem_wait): wait for the given semaphore for
+ * a given timeout
+ * Note: timeout = 0 means wait forever
+ */
+u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
+{
+	int err;
+	if (!timeout)
+		return sem_wait(&sem->sem);
+	while (timeout)
+	{
+		err = sem_trywait(&sem->sem);
+		if (err != -1)
+			return err;
+		timeout--;
+	}
+	return SYS_ARCH_TIMEOUT;
+}
+
+/* sys_mbox_valid() : returns if the given mailbox
+ * is valid
+ */
+int sys_mbox_valid(sys_mbox_t * mbox)
+{
+	return mbox->valid;
+}
+
+/* sys_arch_mbox_fetch(): wait for the given mailbox for a specified
+ * amount of time.
+ * Note: timeout = 0 means wait forever
+ */
+u32_t sys_arch_mbox_fetch(sys_mbox_t * mbox, void **msg, u32_t timeout)
+{
+	if (!timeout)
+		return mailbox_ptr_fetch(&mbox->mailbox,msg);
+
+	while(timeout)
+	{
+		if (!mailbox_ptr_tryfetch(&mbox->mailbox,msg))
+			return 0;
+		timeout--;
+	}
+
+	return SYS_ARCH_TIMEOUT;
+}
+
+/* sys_mbox_free() : free the given mailbox, release the system resources
+ * and set mbox to invalid
+ */
+void sys_mbox_free(sys_mbox_t* mbox)
+{
+	mbox->valid = FALSE;
+	mailbox_ptr_destroy(&mbox->mailbox);
+}
+
+/* sys_arch_mbox_tryfetch(): poll for new data in mailbox
+ *
+ */
+u32_t sys_arch_mbox_tryfetch(sys_mbox_t* mbox, void** msg)
+{
+	return mailbox_ptr_tryfetch(&mbox->mailbox,msg);
+}
+
+/* sys_mbox_new(): create a new mailbox with a minimum size of "size"
+ *
+ */
+err_t sys_mbox_new(sys_mbox_t* mbox,int size)
+{
+	mbox->valid = TRUE;
+	return mailbox_ptr_init(&mbox->mailbox);
+}
+
+/* sys_mbox_set_invalid(): set the given mailbox to invald
+ * Note: system resources are NOT freed
+ */
+void sys_mbox_set_invalid(sys_mbox_t* mbox)
+{
+	mbox->valid = FALSE;
+}
+
+/* sys_mbox_trypost(): try to post data to the mailbox
+ * Note: There is at the moment no try post implemented
+ * so we use the normal post instead
+ */
+err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
+{
+	return mailbox_ptr_post(&mbox->mailbox,msg);
+}
+
+/* sys_mbox_post(): post new data to the mailbox
+ *
+ */
+void sys_mbox_post(sys_mbox_t* mbox,void* msg)
+{
+	mailbox_ptr_post(&mbox->mailbox,msg);
+}
+
+/* sys_mutex_lock(): lock the given mutex
+ * Note: There is no specific mutex in MetalSVM
+ * so we use a semaphore with 1 element
+ */
+void sys_mutex_lock(sys_mutex_t* mutex)
+{
+	sem_wait(mutex);
+}
+
+/* sys_mutex_unlock(): unlock the given mutex
+ *
+ */
+void sys_mutex_unlock(sys_mutex_t* mutex)
+{
+	sem_post(mutex);
+}
+
+/* sys_mutex_new(): create a new mutex
+ *
+ */
+err_t sys_mutex_new(sys_mutex_t * mutex)
+{
+	sem_init(mutex,1);
+	return 0;
+}
+
+#endif /* !NO_SYS */

lwip/src/include/arch/sys_arch.h

@@ -1,20 +1,22 @@
-/*
- * Copyright (c) 2010 Stefan Lankes, Chair for Operating Systems, RWTH Aachen University, Germany
- * All rights reserved
- */
-#ifndef __ARCH_SYS_ARCH_H__
-#define __ARCH_SYS_ARCH_H__
-
-#include <metalsvm/tasks.h>
-#include <metalsvm/semaphore.h>
-#include <metalsvm/mailbox.h>
-
-#define SYS_MBOX_NULL NULL
-#define SYS_SEM_NULL  NULL
-
-typedef sem_t* sys_sem_t;
-typedef mailbox_ptr_t* sys_mbox_t;
-typedef tid_t*  sys_thread_t;
-
-#endif /* __ARCH_SYS_ARCH_H__ */
-
+#ifndef __ARCH_SYS_ARCH_H__
+#define __ARCH_SYS_ARCH_H__
+
+#include <asm/tasks.h>
+#include <metalsvm/mailbox.h>
+
+typedef sem_t sys_mutex_t;
+
+typedef struct
+{
+	sem_t		sem;
+	int		valid;
+} sys_sem_t;
+
+typedef struct 
+{	mailbox_ptr_t	mailbox;
+	int		valid;
+} sys_mbox_t;
+
+typedef tid_t*		sys_thread_t;
+
+#endif /* __ARCH_SYS_ARCH_H__ */

lwip/src/include/lwipopts.h

@@ -7,7 +7,7 @@
  * NO_SYS==1: Provides VERY minimal functionality. Otherwise,
  * use lwIP facilities.
  */
-#define NO_SYS			1
+#define NO_SYS			0
 
 /**
  * NO_SYS_NO_TIMERS==1: Drop support for sys_timeout when NO_SYS==1
@@ -40,6 +40,30 @@
  */
 #define LWIP_TCP		1
 
+/**
+ * TCP_QUEUE_OOSEQ==1: TCP will queue segments that arrive out of order.
+ * Define to 0 if your device is low on memory.
+ */
+#ifndef TCP_QUEUE_OOSEQ
+#define TCP_QUEUE_OOSEQ		0
+#endif
+
+/**
+ * TCP_SND_BUF: TCP sender buffer space (bytes). 
+ */
+#ifndef TCP_SND_BUF
+#define TCP_SND_BUF		2048
+#endif
+
+/**
+ * TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least
+ * as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work.
+ */
+#ifndef TCP_SND_QUEUELEN
+#define TCP_SND_QUEUELEN	((4 * (TCP_SND_BUF) + (TCP_MSS - 1))/(TCP_MSS))
+#endif
+
+
 /**
  * LWIP_BROADCAST_PING==1: respond to broadcast pings (default is unicast only)
  */
@@ -53,13 +77,13 @@
 /**
  * LWIP_HAVE_LOOPIF==1: Support loop interface (127.0.0.1) and loopif.c
  */
-#define LWIP_HAVE_LOOPIF	1
+#define LWIP_HAVE_LOOPIF	0
 
 /**
  * LWIP_NETIF_LOOPBACK==1: Support sending packets with a destination IP
  * address equal to the netif IP address, looping them back up the stack.
  */
-#define LWIP_NETIF_LOOPBACK	1
+#define LWIP_NETIF_LOOPBACK	0
 
 /**
  * MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts.