fixed the compiling error while defined RT_USING_PPP

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2467 bbd45198-f89e-11dd-88c7-29a3b14d5316

components/net/lwip/SConscript

@@ -47,8 +47,6 @@ src/core/snmp/mib_structs.c
 src/core/snmp/msg_in.c
 src/core/snmp/msg_out.c
 """)
-if GetDepend(['RT_LWIP_PPP']):
-    src += ppp_src
 
 ppp_src = Split("""
 src/netif/ppp/auth.c
@@ -67,18 +65,18 @@ src/netif/ppp/vj.c
 """)
 
 # The set of source files associated with this SConscript file.
-path = [RTT_ROOT + '/components/net/lwip/src',
-    RTT_ROOT + '/components/net/lwip/src/include',
-    RTT_ROOT + '/components/net/lwip/src/include/ipv4',
-    RTT_ROOT + '/components/net/lwip/src/arch/include',
-    RTT_ROOT + '/components/net/lwip/src/include/netif']
+path = [GetCurrentDir() + '/src',
+    GetCurrentDir() + '/src/include',
+    GetCurrentDir() + '/src/include/ipv4',
+    GetCurrentDir() + '/src/arch/include',
+    GetCurrentDir() + '/src/include/netif']
 
 if GetDepend(['RT_LWIP_SNMP']):
     src += snmp_src
 
 if GetDepend(['RT_LWIP_PPP']):
     src += ppp_src
-    path += [RTT_ROOT + '/components/net/lwip/src/netif/ppp']
+    path += [GetCurrentDir() + '/src/netif/ppp']
 
 # For testing apps
 if GetDepend(['RT_USING_NETUTILS']):

components/net/lwip/src/arch/sys_arch.c

@@ -9,98 +9,101 @@
 #include "lwip/netif.h"
 #include "lwip/tcpip.h"
 #include "netif/ethernetif.h"
+#include "lwip/sio.h"
 
 #include <string.h>
 
 static err_t netif_device_init(struct netif *netif)
 {
-	struct eth_device *ethif;
+    struct eth_device *ethif;
 
-	ethif = (struct eth_device*)netif->state;
-	if (ethif != RT_NULL)
-	{
-		rt_device_t device;
+    ethif = (struct eth_device *)netif->state;
+    if (ethif != RT_NULL)
+    {
+        rt_device_t device;
 
-		/* get device object */
-		device = (rt_device_t) ethif;
-		if (rt_device_init(device) != RT_EOK)
-		{
-			return ERR_IF;
-		}
+        /* get device object */
+        device = (rt_device_t) ethif;
+        if (rt_device_init(device) != RT_EOK)
+        {
+            return ERR_IF;
+        }
 
-		/* copy device flags to netif flags */
-		netif->flags = ethif->flags;
+        /* copy device flags to netif flags */
+        netif->flags = ethif->flags;
 
-		return ERR_OK;
-	}
+        return ERR_OK;
+    }
 
-	return ERR_IF;
+    return ERR_IF;
 }
 
 static void tcpip_init_done_callback(void *arg)
 {
-	rt_device_t device;
-	struct eth_device *ethif;
-	struct ip_addr ipaddr, netmask, gw;
-	struct rt_list_node* node;
-	struct rt_object* object;
-	struct rt_object_information *information;
+    rt_device_t device;
+    struct eth_device *ethif;
+    struct ip_addr ipaddr, netmask, gw;
+    struct rt_list_node* node;
+    struct rt_object* object;
+    struct rt_object_information *information;
 
-	extern struct rt_object_information rt_object_container[];
+    extern struct rt_object_information rt_object_container[];
 
-	LWIP_ASSERT("invalid arg.\n",arg);
+    LWIP_ASSERT("invalid arg.\n",arg);
 
-	IP4_ADDR(&gw, 0,0,0,0);
-	IP4_ADDR(&ipaddr, 0,0,0,0);
-	IP4_ADDR(&netmask, 0,0,0,0);
+    IP4_ADDR(&gw, 0,0,0,0);
+    IP4_ADDR(&ipaddr, 0,0,0,0);
+    IP4_ADDR(&netmask, 0,0,0,0);
 
-	/* enter critical */
-	rt_enter_critical();
+    /* enter critical */
+    rt_enter_critical();
 
-	/* for each network interfaces */
-	information = &rt_object_container[RT_Object_Class_Device];
-	for (node = information->object_list.next; node != &(information->object_list); node = node->next)
-	{
-		object = rt_list_entry(node, struct rt_object, list);
-		device = (rt_device_t) object;
-		if (device->type == RT_Device_Class_NetIf)
-		{
-			ethif = (struct eth_device*)device;
+    /* for each network interfaces */
+    information = &rt_object_container[RT_Object_Class_Device];
+    for (node = information->object_list.next;
+         node != &(information->object_list);
+         node = node->next)
+    {
+        object = rt_list_entry(node, struct rt_object, list);
+        device = (rt_device_t)object;
+        if (device->type == RT_Device_Class_NetIf)
+        {
+            ethif = (struct eth_device *)device;
 
-			/* leave critical */
-			rt_exit_critical();
+            /* leave critical */
+            rt_exit_critical();
 
-			netif_add(ethif->netif, &ipaddr, &netmask, &gw,
-				ethif, netif_device_init, tcpip_input);
+            netif_add(ethif->netif, &ipaddr, &netmask, &gw,
+                      ethif, netif_device_init, tcpip_input);
 
-			if (netif_default == RT_NULL)
-				netif_set_default(ethif->netif);
+            if (netif_default == RT_NULL)
+                netif_set_default(ethif->netif);
 
 #if LWIP_DHCP
-			if (ethif->flags & NETIF_FLAG_DHCP)
-			{
-				/* if this interface uses DHCP, start the DHCP client */
-				dhcp_start(ethif->netif);
-			}
-			else
+            if (ethif->flags & NETIF_FLAG_DHCP)
+            {
+                /* if this interface uses DHCP, start the DHCP client */
+                dhcp_start(ethif->netif);
+            }
+            else
 #endif
-			{
-				/* set interface up */
-				netif_set_up(ethif->netif);
-			}
+            {
+                /* set interface up */
+                netif_set_up(ethif->netif);
+            }
 
 #ifdef LWIP_NETIF_LINK_CALLBACK
-			netif_set_link_up(ethif->netif);
+            netif_set_link_up(ethif->netif);
 #endif
 
-			/* enter critical */
-			rt_enter_critical();
-		}
-	}
+            /* enter critical */
+            rt_enter_critical();
+        }
+    }
 
-	/* leave critical */
-	rt_exit_critical();
-	rt_sem_release((rt_sem_t)arg);
+    /* leave critical */
+    rt_exit_critical();
+    rt_sem_release((rt_sem_t)arg);
 }
 
 /**
@@ -108,212 +111,224 @@ static void tcpip_init_done_callback(void *arg)
  */
 void lwip_system_init(void)
 {
-	rt_err_t rc;
-	struct rt_semaphore done_sem;
+    rt_err_t rc;
+    struct rt_semaphore done_sem;
 
-	/* set default netif to NULL */
-	netif_default = RT_NULL;
+    /* set default netif to NULL */
+    netif_default = RT_NULL;
 
-	rc = rt_sem_init(&done_sem, "done", 0, RT_IPC_FLAG_FIFO);
+    rc = rt_sem_init(&done_sem, "done", 0, RT_IPC_FLAG_FIFO);
 
-	if(rc != RT_EOK)
-	{
-    	LWIP_ASSERT("Failed to create semaphore", 0);
-		return;
-	}
+    if (rc != RT_EOK)
+    {
+        LWIP_ASSERT("Failed to create semaphore", 0);
 
-	tcpip_init(tcpip_init_done_callback,(void *)&done_sem);
+        return;
+    }
 
-	/* waiting for initialization done */
-	if (rt_sem_take(&done_sem, RT_WAITING_FOREVER) != RT_EOK)
-	{
-		rt_sem_detach(&done_sem);
-		return;
-	}
-	rt_sem_detach(&done_sem);
+    tcpip_init(tcpip_init_done_callback, (void *)&done_sem);
 
-	/* set default ip address */
+    /* waiting for initialization done */
+    if (rt_sem_take(&done_sem, RT_WAITING_FOREVER) != RT_EOK)
+    {
+        rt_sem_detach(&done_sem);
+
+        return;
+    }
+    rt_sem_detach(&done_sem);
+
+    /* set default ip address */
 #if !LWIP_DHCP
-	if (netif_default != RT_NULL)
-	{
-		struct ip_addr ipaddr, netmask, gw;
+    if (netif_default != RT_NULL)
+    {
+        struct ip_addr ipaddr, netmask, gw;
 
-		IP4_ADDR(&ipaddr, RT_LWIP_IPADDR0, RT_LWIP_IPADDR1, RT_LWIP_IPADDR2, RT_LWIP_IPADDR3);
-		IP4_ADDR(&gw, RT_LWIP_GWADDR0, RT_LWIP_GWADDR1, RT_LWIP_GWADDR2, RT_LWIP_GWADDR3);
-		IP4_ADDR(&netmask, RT_LWIP_MSKADDR0, RT_LWIP_MSKADDR1, RT_LWIP_MSKADDR2, RT_LWIP_MSKADDR3);
+        IP4_ADDR(&ipaddr, RT_LWIP_IPADDR0, RT_LWIP_IPADDR1, RT_LWIP_IPADDR2, RT_LWIP_IPADDR3);
+        IP4_ADDR(&gw, RT_LWIP_GWADDR0, RT_LWIP_GWADDR1, RT_LWIP_GWADDR2, RT_LWIP_GWADDR3);
+        IP4_ADDR(&netmask, RT_LWIP_MSKADDR0, RT_LWIP_MSKADDR1, RT_LWIP_MSKADDR2, RT_LWIP_MSKADDR3);
 
-		netifapi_netif_set_addr(netif_default, &ipaddr, &netmask, &gw);
-	}
+        netifapi_netif_set_addr(netif_default, &ipaddr, &netmask, &gw);
+    }
 #endif
 }
 
 void sys_init(void)
 {
-	/* nothing on RT-Thread porting */
+    /* nothing on RT-Thread porting */
 }
 
 void lwip_sys_init(void)
 {
-	lwip_system_init();
+    lwip_system_init();
 }
 
 err_t sys_sem_new(sys_sem_t *sem, u8_t count)
 {
-	static unsigned short counter = 0;
-	char tname[RT_NAME_MAX];
-	sys_sem_t tmpsem;
+    static unsigned short counter = 0;
+    char tname[RT_NAME_MAX];
+    sys_sem_t tmpsem;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_SEM_NAME, counter);
-	counter++;
+    rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_SEM_NAME, counter);
+    counter ++;
 
-	tmpsem = rt_sem_create(tname, count, RT_IPC_FLAG_FIFO);
-	if( tmpsem == RT_NULL )
-		return ERR_MEM;
-	else
-	{
-		*sem = tmpsem;
-		return ERR_OK;
-	}
-}
+    tmpsem = rt_sem_create(tname, count, RT_IPC_FLAG_FIFO);
+    if (tmpsem == RT_NULL)
+        return ERR_MEM;
+    else
+    {
+        *sem = tmpsem;
 
+        return ERR_OK;
+    }
+}
 
 void sys_sem_free(sys_sem_t *sem)
 {
-	RT_DEBUG_NOT_IN_INTERRUPT;
-	rt_sem_delete(*sem);
+    RT_DEBUG_NOT_IN_INTERRUPT;
+    rt_sem_delete(*sem);
 }
 
-
 void sys_sem_signal(sys_sem_t *sem)
 {
-	rt_sem_release(*sem);
+    rt_sem_release(*sem);
 }
 
 u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
 {
-	rt_err_t ret;
-	s32_t t;
-	u32_t tick;
-
-	RT_DEBUG_NOT_IN_INTERRUPT;
-	
-	/* get the begin tick */
-	tick = rt_tick_get();
-	if(timeout == 0) t = RT_WAITING_FOREVER;
-	else
-	{
-		/* convert msecond to os tick */
-		if (timeout < (1000/RT_TICK_PER_SECOND))
-			t = 1;
-		else
-			t = timeout / (1000/RT_TICK_PER_SECOND);
-	}
-
-	ret = rt_sem_take(*sem, t);
-
-	if (ret == -RT_ETIMEOUT)
-		return SYS_ARCH_TIMEOUT;
-	else
-	{
-		if (ret == RT_EOK)
-			ret = 1;
-	}
-
-	/* get elapse msecond */
-	tick = rt_tick_get() - tick;
-
-	/* convert tick to msecond */
-	tick = tick * (1000/RT_TICK_PER_SECOND);
-	if (tick == 0)
-		tick = 1;
-
-	return tick;
+    rt_err_t ret;
+    s32_t t;
+    u32_t tick;
+
+    RT_DEBUG_NOT_IN_INTERRUPT;
+
+    /* get the begin tick */
+    tick = rt_tick_get();
+    if (timeout == 0)
+        t = RT_WAITING_FOREVER;
+    else
+    {
+        /* convert msecond to os tick */
+        if (timeout < (1000/RT_TICK_PER_SECOND))
+            t = 1;
+        else
+            t = timeout / (1000/RT_TICK_PER_SECOND);
+    }
+
+    ret = rt_sem_take(*sem, t);
+
+    if (ret == -RT_ETIMEOUT)
+        return SYS_ARCH_TIMEOUT;
+    else
+    {
+        if (ret == RT_EOK)
+            ret = 1;
+    }
+
+    /* get elapse msecond */
+    tick = rt_tick_get() - tick;
+
+    /* convert tick to msecond */
+    tick = tick * (1000 / RT_TICK_PER_SECOND);
+    if (tick == 0)
+        tick = 1;
+
+    return tick;
 }
 
 #ifndef sys_sem_valid
-/** Check if a semaphore is valid/allocated: return 1 for valid, 0 for invalid */
+/** Check if a semaphore is valid/allocated:
+ *  return 1 for valid, 0 for invalid
+ */
 int sys_sem_valid(sys_sem_t *sem)
 {
-	return (int)(*sem);
+    return (int)(*sem);
 }
 #endif
+
 #ifndef sys_sem_set_invalid
-/** Set a semaphore invalid so that sys_sem_valid returns 0 */
+/** Set a semaphore invalid so that sys_sem_valid returns 0
+ */
 void sys_sem_set_invalid(sys_sem_t *sem)
 {
-	*sem = RT_NULL;
+    *sem = RT_NULL;
 }
 #endif
 
-
 /* ====================== Mutex ====================== */
 
 /** Create a new mutex
  * @param mutex pointer to the mutex to create
- * @return a new mutex */
+ * @return a new mutex
+ */
 err_t sys_mutex_new(sys_mutex_t *mutex)
 {
-	static unsigned short counter = 0;
-	char tname[RT_NAME_MAX];
-	sys_mutex_t tmpmutex;
+    static unsigned short counter = 0;
+    char tname[RT_NAME_MAX];
+    sys_mutex_t tmpmutex;
+
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_MUTEX_NAME, counter);
+    counter ++;
 
-	rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_MUTEX_NAME, counter);
-	counter++;
+    tmpmutex = rt_mutex_create(tname, RT_IPC_FLAG_FIFO);
+    if (tmpmutex == RT_NULL)
+        return ERR_MEM;
+    else
+    {
+        *mutex = tmpmutex;
 
-	tmpmutex = rt_mutex_create(tname, RT_IPC_FLAG_FIFO);
-	if( tmpmutex == RT_NULL )
-		return ERR_MEM;
-	else
-	{
-		*mutex = tmpmutex;
-		return ERR_OK;
-	}
+        return ERR_OK;
+    }
 }
 
 /** Lock a mutex
- * @param mutex the mutex to lock */
+ * @param mutex the mutex to lock
+ */
 void sys_mutex_lock(sys_mutex_t *mutex)
 {
-	RT_DEBUG_NOT_IN_INTERRUPT;
-	rt_mutex_take(*mutex, RT_WAITING_FOREVER);
+    RT_DEBUG_NOT_IN_INTERRUPT;
+    rt_mutex_take(*mutex, RT_WAITING_FOREVER);
 
-	return;
+    return;
 }
 
-
 /** Unlock a mutex
- * @param mutex the mutex to unlock */
+ * @param mutex the mutex to unlock
+ */
 void sys_mutex_unlock(sys_mutex_t *mutex)
 {
-	rt_mutex_release(*mutex);
+    rt_mutex_release(*mutex);
 }
 
 /** Delete a semaphore
- * @param mutex the mutex to delete */
+ * @param mutex the mutex to delete
+ */
 void sys_mutex_free(sys_mutex_t *mutex)
 {
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	rt_mutex_delete(*mutex);
+    rt_mutex_delete(*mutex);
 }
 
 #ifndef sys_mutex_valid
-/** Check if a mutex is valid/allocated: return 1 for valid, 0 for invalid */
+/** Check if a mutex is valid/allocated:
+ *  return 1 for valid, 0 for invalid
+ */
 int sys_mutex_valid(sys_mutex_t *mutex)
 {
-	return (int)(*mutex);
+    return (int)(*mutex);
 }
 #endif
 
 #ifndef sys_mutex_set_invalid
-/** Set a mutex invalid so that sys_mutex_valid returns 0 */
+/** Set a mutex invalid so that sys_mutex_valid returns 0
+ */
 void sys_mutex_set_invalid(sys_mutex_t *mutex)
 {
-	*mutex = RT_NULL;
+    *mutex = RT_NULL;
 }
 #endif
 
@@ -321,53 +336,55 @@ void sys_mutex_set_invalid(sys_mutex_t *mutex)
 
 err_t sys_mbox_new(sys_mbox_t *mbox, int size)
 {
-	static unsigned short counter = 0;
-	char tname[RT_NAME_MAX];
-	sys_mbox_t tmpmbox;
+    static unsigned short counter = 0;
+    char tname[RT_NAME_MAX];
+    sys_mbox_t tmpmbox;
+
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_MBOX_NAME, counter);
+    counter ++;
 
-	rt_snprintf(tname, RT_NAME_MAX, "%s%d", SYS_LWIP_MBOX_NAME, counter);
-	counter++;
+    tmpmbox = rt_mb_create(tname, size, RT_IPC_FLAG_FIFO);
+    if (tmpmbox != RT_NULL)
+    {
+        *mbox = tmpmbox;
 
-	tmpmbox = rt_mb_create(tname, size, RT_IPC_FLAG_FIFO);
-	if( tmpmbox != RT_NULL )
-	{
-		*mbox = tmpmbox;
-		return ERR_OK;
-	}
+        return ERR_OK;
+    }
 
-	return ERR_MEM;
+    return ERR_MEM;
 }
 
 void sys_mbox_free(sys_mbox_t *mbox)
 {
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	rt_mb_delete(*mbox);
+    rt_mb_delete(*mbox);
 
-	return;
+    return;
 }
 
 /** Post a message to an mbox - may not fail
  * -> blocks if full, only used from tasks not from ISR
  * @param mbox mbox to posts the message
- * @param msg message to post (ATTENTION: can be NULL) */
+ * @param msg message to post (ATTENTION: can be NULL)
+ */
 void sys_mbox_post(sys_mbox_t *mbox, void *msg)
 {
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	rt_mb_send_wait(*mbox, (rt_uint32_t)msg,RT_WAITING_FOREVER);
+    rt_mb_send_wait(*mbox, (rt_uint32_t)msg, RT_WAITING_FOREVER);
 
-	return;
+    return;
 }
 
 err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
 {
-	if (rt_mb_send(*mbox, (rt_uint32_t)msg) == RT_EOK)
-		return ERR_OK;
+    if (rt_mb_send(*mbox, (rt_uint32_t)msg) == RT_EOK)
+        return ERR_OK;
 
-	return ERR_MEM;
+    return ERR_MEM;
 }
 
 /** Wait for a new message to arrive in the mbox
@@ -376,47 +393,48 @@ err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
  * @param timeout maximum time (in milliseconds) to wait for a message
  * @return time (in milliseconds) waited for a message, may be 0 if not waited
            or SYS_ARCH_TIMEOUT on timeout
- *         The returned time has to be accurate to prevent timer jitter! */
+ *         The returned time has to be accurate to prevent timer jitter!
+ */
 u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
 {
-	rt_err_t ret;
-	s32_t t;
-	u32_t tick;
-
-	RT_DEBUG_NOT_IN_INTERRUPT;
-
-	/* get the begin tick */
-	tick = rt_tick_get();
-
-	if(timeout == 0)
-		t = RT_WAITING_FOREVER;
-	else
-	{
-		/* convirt msecond to os tick */
-		if (timeout < (1000/RT_TICK_PER_SECOND))
-			t = 1;
-		else
-			t = timeout / (1000/RT_TICK_PER_SECOND);
-	}
-
-	ret = rt_mb_recv(*mbox, (rt_uint32_t *)msg, t);
-
-	if(ret == -RT_ETIMEOUT)
-		return SYS_ARCH_TIMEOUT;
-	else
-	{
-		LWIP_ASSERT("rt_mb_recv returned with error!", ret == RT_EOK);
-	}
-
-	/* get elapse msecond */
-	tick = rt_tick_get() - tick;
-
-	/* convert tick to msecond */
-	tick = tick * (1000/RT_TICK_PER_SECOND);
-	if (tick == 0)
-		tick = 1;
-
-	return tick;
+    rt_err_t ret;
+    s32_t t;
+    u32_t tick;
+
+    RT_DEBUG_NOT_IN_INTERRUPT;
+
+    /* get the begin tick */
+    tick = rt_tick_get();
+
+    if(timeout == 0)
+        t = RT_WAITING_FOREVER;
+    else
+    {
+        /* convirt msecond to os tick */
+        if (timeout < (1000/RT_TICK_PER_SECOND))
+            t = 1;
+        else
+            t = timeout / (1000/RT_TICK_PER_SECOND);
+    }
+
+    ret = rt_mb_recv(*mbox, (rt_uint32_t *)msg, t);
+
+    if(ret == -RT_ETIMEOUT)
+        return SYS_ARCH_TIMEOUT;
+    else
+    {
+        LWIP_ASSERT("rt_mb_recv returned with error!", ret == RT_EOK);
+    }
+
+    /* get elapse msecond */
+    tick = rt_tick_get() - tick;
+
+    /* convert tick to msecond */
+    tick = tick * (1000 / RT_TICK_PER_SECOND);
+    if (tick == 0)
+        tick = 1;
+
+    return tick;
 }
 
 /** Wait for a new message to arrive in the mbox
@@ -424,80 +442,130 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
  * @param msg pointer where the message is stored
  * @param timeout maximum time (in milliseconds) to wait for a message
  * @return 0 (milliseconds) if a message has been received
- *         or SYS_MBOX_EMPTY if the mailbox is empty */
+ *         or SYS_MBOX_EMPTY if the mailbox is empty
+ */
 u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
 {
-	int ret;
+    int ret;
 
-	ret = rt_mb_recv(*mbox, (rt_uint32_t *)msg, 0);
+    ret = rt_mb_recv(*mbox, (rt_uint32_t *)msg, 0);
 
-	if(ret == -RT_ETIMEOUT)
-		return SYS_ARCH_TIMEOUT;
-	else
-	{
-		if (ret == RT_EOK) 
-			ret = 1;
-	}
+    if(ret == -RT_ETIMEOUT)
+        return SYS_ARCH_TIMEOUT;
+    else
+    {
+        if (ret == RT_EOK) 
+            ret = 1;
+    }
 
-	return ret;
+    return ret;
 }
 
 #ifndef sys_mbox_valid
-/** Check if an mbox is valid/allocated: return 1 for valid, 0 for invalid */
+/** Check if an mbox is valid/allocated:
+ *  return 1 for valid, 0 for invalid
+ */
 int sys_mbox_valid(sys_mbox_t *mbox)
 {
-	return (int)(*mbox);
+    return (int)(*mbox);
 }
 #endif
+
 #ifndef sys_mbox_set_invalid
-/** Set an mbox invalid so that sys_mbox_valid returns 0 */
+/** Set an mbox invalid so that sys_mbox_valid returns 0
+ */
 void sys_mbox_set_invalid(sys_mbox_t *mbox)
 {
-	*mbox = RT_NULL;
+    *mbox = RT_NULL;
 }
 #endif
 
-
-
-
 /* ====================== System ====================== */
 
-sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
+sys_thread_t sys_thread_new(const char    *name,
+                            lwip_thread_fn thread,
+                            void          *arg,
+                            int            stacksize,
+                            int            prio)
 {
-	rt_thread_t t;
+    rt_thread_t t;
 
-	RT_DEBUG_NOT_IN_INTERRUPT;
+    RT_DEBUG_NOT_IN_INTERRUPT;
 
-	/* create thread */
-	t = rt_thread_create(name, thread, arg, stacksize, prio, 20);
-	RT_ASSERT(t != RT_NULL);
+    /* create thread */
+    t = rt_thread_create(name, thread, arg, stacksize, prio, 20);
+    RT_ASSERT(t != RT_NULL);
 
-	/* startup thread */
-	rt_thread_startup(t);
+    /* startup thread */
+    rt_thread_startup(t);
 
-	return t;
+    return t;
 }
 
 sys_prot_t sys_arch_protect(void)
 {
-	rt_base_t level;
+    rt_base_t level;
 
-	/* disable interrupt */
-	level = rt_hw_interrupt_disable();
-	return level;
+    /* disable interrupt */
+    level = rt_hw_interrupt_disable();
+
+    return level;
 }
 
 void sys_arch_unprotect(sys_prot_t pval)
 {
-	/* enable interrupt */
-	rt_hw_interrupt_enable(pval);
+    /* enable interrupt */
+    rt_hw_interrupt_enable(pval);
+
+    return;
+}
 
-	return;
+void sys_arch_assert(const char *file, int line)
+{
+    rt_kprintf("\nAssertion: %d in %s, thread %s\n",
+               line, file, rt_thread_self()->name);
+    RT_ASSERT(0);
+}
+
+u32_t sys_jiffies(void)
+{
+    return rt_tick_get();
+}
+
+u32_t sio_read(sio_fd_t fd, u8_t *buf, u32_t size)
+{
+    u32_t len, i;
+
+    RT_ASSERT(fd != RT_NULL);
+
+    len = rt_device_read((rt_device_t)fd, 0, buf, size);
+    if (len <= 0)
+        return 0;
+
+    return len;
+}
+
+u32_t sio_write(sio_fd_t fd, u8_t *buf, u32_t size)
+{
+    u32_t i;
+    RT_ASSERT(fd != RT_NULL);
+
+    return rt_device_write((rt_device_t)fd, 0, buf, size);
+}
+
+void sio_read_abort(sio_fd_t fd)
+{
+    rt_kprintf("read_abort\n");
 }
 
-void sys_arch_assert(const char* file, int line)
+void ppp_trace(int level, const char *format, ...)
 {
-	rt_kprintf("\nAssertion: %d in %s, thread %s\n", line, file,
-        rt_thread_self()->name);
-	RT_ASSERT(0);
+    va_list args;
+    rt_size_t length;
+    static char rt_log_buf[RT_CONSOLEBUF_SIZE];
+
+    va_start(args, format);
+    length = rt_vsprintf(rt_log_buf, format, args);
+    rt_device_write((rt_device_t)rt_console_get_device(), 0, rt_log_buf, length);
+    va_end(args);
 }