#include "lwip/opt.h"
-#include "lwip/sys.h"
+#if !NO_SYS /* don't build if not configured for use in lwipopts.h */
+#include "lwip/sys.h"
#include "lwip/memp.h"
+#include "lwip/mem.h"
#include "lwip/pbuf.h"
-
+#include "lwip/tcpip.h"
+#include "lwip/init.h"
#include "netif/etharp.h"
#include "netif/ppp_oe.h"
-#include "lwip/ip.h"
-#include "lwip/ip_frag.h"
-#include "lwip/udp.h"
-#include "lwip/tcp.h"
-
-#include "lwip/tcpip.h"
-#include "lwip/igmp.h"
-
-#if !NO_SYS
-
/* global variables */
-static void (* tcpip_init_done)(void *arg) = NULL;
-static void *tcpip_init_done_arg = NULL;
-static sys_mbox_t mbox = SYS_MBOX_NULL;
+static tcpip_init_done_fn tcpip_init_done;
+static void *tcpip_init_done_arg;
+static sys_mbox_t mbox;
#if LWIP_TCPIP_CORE_LOCKING
/** The global semaphore to lock the stack. */
-sys_sem_t lock_tcpip_core = 0;
+sys_mutex_t lock_tcpip_core;
#endif /* LWIP_TCPIP_CORE_LOCKING */
-#if LWIP_TCP
-/* global variable that shows if the tcp timer is currently scheduled or not */
-static int tcpip_tcp_timer_active = 0;
-
-/**
- * Timer callback function that calls tcp_tmr() and reschedules itself.
- *
- * @param arg unused argument
- */
-static void
-tcpip_tcp_timer(void *arg)
-{
- LWIP_UNUSED_ARG(arg);
-
- /* call TCP timer handler */
- tcp_tmr();
- /* timer still needed? */
- if (tcp_active_pcbs || tcp_tw_pcbs) {
- /* restart timer */
- sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL);
- } else {
- /* disable timer */
- tcpip_tcp_timer_active = 0;
- }
-}
-
-#if !NO_SYS
-/**
- * Called from TCP_REG when registering a new PCB:
- * the reason is to have the TCP timer only running when
- * there are active (or time-wait) PCBs.
- */
-void
-tcp_timer_needed(void)
-{
- /* timer is off but needed again? */
- if (!tcpip_tcp_timer_active && (tcp_active_pcbs || tcp_tw_pcbs)) {
- /* enable and start timer */
- tcpip_tcp_timer_active = 1;
- sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL);
- }
-}
-#endif /* !NO_SYS */
-#endif /* LWIP_TCP */
-
-#if IP_REASSEMBLY
-/**
- * Timer callback function that calls ip_reass_tmr() and reschedules itself.
- *
- * @param arg unused argument
- */
-static void
-ip_reass_timer(void *arg)
-{
- LWIP_UNUSED_ARG(arg);
- LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: ip_reass_tmr()\n"));
- ip_reass_tmr();
- sys_timeout(IP_TMR_INTERVAL, ip_reass_timer, NULL);
-}
-#endif /* IP_REASSEMBLY */
-
-#if LWIP_ARP
-/**
- * Timer callback function that calls etharp_tmr() and reschedules itself.
- *
- * @param arg unused argument
- */
-static void
-arp_timer(void *arg)
-{
- LWIP_UNUSED_ARG(arg);
- LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: etharp_tmr()\n"));
- etharp_tmr();
- sys_timeout(ARP_TMR_INTERVAL, arp_timer, NULL);
-}
-#endif /* LWIP_ARP */
-
-#if LWIP_DHCP
-/**
- * Timer callback function that calls dhcp_coarse_tmr() and reschedules itself.
- *
- * @param arg unused argument
- */
-static void
-dhcp_timer_coarse(void *arg)
-{
- LWIP_UNUSED_ARG(arg);
- LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: dhcp_coarse_tmr()\n"));
- dhcp_coarse_tmr();
- sys_timeout(DHCP_COARSE_TIMER_SECS*1000, dhcp_timer_coarse, NULL);
-}
-
-/**
- * Timer callback function that calls dhcp_fine_tmr() and reschedules itself.
- *
- * @param arg unused argument
- */
-static void
-dhcp_timer_fine(void *arg)
-{
- LWIP_UNUSED_ARG(arg);
- LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: dhcp_fine_tmr()\n"));
- dhcp_fine_tmr();
- sys_timeout(DHCP_FINE_TIMER_MSECS, dhcp_timer_fine, NULL);
-}
-#endif /* LWIP_DHCP */
-
-#if LWIP_AUTOIP
-/**
- * Timer callback function that calls autoip_tmr() and reschedules itself.
- *
- * @param arg unused argument
- */
-static void
-autoip_timer(void *arg)
-{
- LWIP_UNUSED_ARG(arg);
- LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: autoip_tmr()\n"));
- autoip_tmr();
- sys_timeout(AUTOIP_TMR_INTERVAL, autoip_timer, NULL);
-}
-#endif /* LWIP_AUTOIP */
-
-#if LWIP_IGMP
-/**
- * Timer callback function that calls igmp_tmr() and reschedules itself.
- *
- * @param arg unused argument
- */
-static void
-igmp_timer(void *arg)
-{
- LWIP_UNUSED_ARG(arg);
- LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: igmp_tmr()\n"));
- igmp_tmr();
- sys_timeout(IGMP_TMR_INTERVAL, igmp_timer, NULL);
-}
-#endif /* LWIP_IGMP */
-
-#if ETHARP_TCPIP_ETHINPUT
-/**
- * Process received ethernet frames. Using this function instead of directly
- * calling ip_input and passing ARP frames through etharp in ethernetif_input,
- * the ARP cache is protected from concurrent access.
- *
- * @param p the recevied packet, p->payload pointing to the ethernet header
- * @param netif the network interface on which the packet was received
- */
-static err_t
-ethernet_input(struct pbuf *p, struct netif *netif)
-{
- struct eth_hdr* ethhdr;
-
- /* points to packet payload, which starts with an Ethernet header */
- ethhdr = p->payload;
-
- switch (htons(ethhdr->type)) {
- /* IP packet? */
- case ETHTYPE_IP:
-#if ETHARP_TRUST_IP_MAC
- /* update ARP table */
- etharp_ip_input( netif, p);
-#endif
- /* skip Ethernet header */
- if(pbuf_header(p, -(s16_t)sizeof(struct eth_hdr))) {
- LWIP_ASSERT("Can't move over header in packet", 0);
- pbuf_free(p);
- p = NULL;
- }
- else
- /* pass to IP layer */
- ip_input(p, netif);
- break;
-
- case ETHTYPE_ARP:
- /* pass p to ARP module */
- etharp_arp_input(netif, (struct eth_addr*)(netif->hwaddr), p);
- break;
-
-#if PPPOE_SUPPORT
- case ETHTYPE_PPPOEDISC: /* PPP Over Ethernet Discovery Stage */
- pppoe_disc_input(netif, p);
- break;
- case ETHTYPE_PPPOE: /* PPP Over Ethernet Session Stage */
- pppoe_data_input(netif, p);
- break;
-#endif /* PPPOE_SUPPORT */
-
- default:
- pbuf_free(p);
- p = NULL;
- break;
- }
-
- return ERR_OK; /* return value ignored */
-}
-#endif /* ETHARP_TCPIP_ETHINPUT */
/**
* The main lwIP thread. This thread has exclusive access to lwIP core functions
struct tcpip_msg *msg;
LWIP_UNUSED_ARG(arg);
-#if IP_REASSEMBLY
- sys_timeout(IP_TMR_INTERVAL, ip_reass_timer, NULL);
-#endif /* IP_REASSEMBLY */
-#if LWIP_ARP
- sys_timeout(ARP_TMR_INTERVAL, arp_timer, NULL);
-#endif /* LWIP_ARP */
-#if LWIP_DHCP
- sys_timeout(DHCP_COARSE_TIMER_SECS*1000, dhcp_timer_coarse, NULL);
- sys_timeout(DHCP_FINE_TIMER_MSECS, dhcp_timer_fine, NULL);
-#endif /* LWIP_DHCP */
-#if LWIP_AUTOIP
- sys_timeout(AUTOIP_TMR_INTERVAL, autoip_timer, NULL);
-#endif /* LWIP_AUTOIP */
-
if (tcpip_init_done != NULL) {
tcpip_init_done(tcpip_init_done_arg);
}
-#if LWIP_IGMP
- igmp_init();
- sys_timeout(IGMP_TMR_INTERVAL, igmp_timer, NULL);
-#endif /* LWIP_IGMP */
-
LOCK_TCPIP_CORE();
while (1) { /* MAIN Loop */
- sys_mbox_fetch(mbox, (void *)&msg);
+ UNLOCK_TCPIP_CORE();
+ LWIP_TCPIP_THREAD_ALIVE();
+ /* wait for a message, timeouts are processed while waiting */
+ sys_timeouts_mbox_fetch(&mbox, (void **)&msg);
+ LOCK_TCPIP_CORE();
switch (msg->type) {
+#if LWIP_NETCONN
case TCPIP_MSG_API:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));
msg->msg.apimsg->function(&(msg->msg.apimsg->msg));
break;
+#endif /* LWIP_NETCONN */
-#if ETHARP_TCPIP_INPUT || ETHARP_TCPIP_ETHINPUT
+#if !LWIP_TCPIP_CORE_LOCKING_INPUT
case TCPIP_MSG_INPKT:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
- msg->msg.inp.f(msg->msg.inp.p, msg->msg.inp.netif);
+#if LWIP_ETHERNET
+ if (msg->msg.inp.netif->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {
+ ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);
+ } else
+#endif /* LWIP_ETHERNET */
+#if LWIP_IPV6
+ if ((*((unsigned char *)(msg->msg.inp.p->payload)) & 0xf0) == 0x60) {
+ ip6_input(msg->msg.inp.p, msg->msg.inp.netif);
+ } else
+#endif /* LWIP_IPV6 */
+ {
+ ip_input(msg->msg.inp.p, msg->msg.inp.netif);
+ }
memp_free(MEMP_TCPIP_MSG_INPKT, msg);
break;
-#endif /* ETHARP_TCPIP_INPUT || ETHARP_TCPIP_ETHINPUT */
+#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
#if LWIP_NETIF_API
case TCPIP_MSG_NETIFAPI:
break;
#endif /* LWIP_NETIF_API */
+#if LWIP_TCPIP_TIMEOUT
+ case TCPIP_MSG_TIMEOUT:
+ LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
+ sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
+ memp_free(MEMP_TCPIP_MSG_API, msg);
+ break;
+ case TCPIP_MSG_UNTIMEOUT:
+ LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg));
+ sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg);
+ memp_free(MEMP_TCPIP_MSG_API, msg);
+ break;
+#endif /* LWIP_TCPIP_TIMEOUT */
+
case TCPIP_MSG_CALLBACK:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));
- msg->msg.cb.f(msg->msg.cb.ctx);
+ msg->msg.cb.function(msg->msg.cb.ctx);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
- case TCPIP_MSG_TIMEOUT:
- LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
- if(msg->msg.tmo.msecs != 0xffffffff)
- sys_timeout (msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
- else
- sys_untimeout (msg->msg.tmo.h, msg->msg.tmo.arg);
- memp_free(MEMP_TCPIP_MSG_API, msg);
+ case TCPIP_MSG_CALLBACK_STATIC:
+ LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK_STATIC %p\n", (void *)msg));
+ msg->msg.cb.function(msg->msg.cb.ctx);
break;
+
default:
+ LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: %d\n", msg->type));
+ LWIP_ASSERT("tcpip_thread: invalid message", 0);
break;
}
}
}
-#if ETHARP_TCPIP_INPUT
/**
- * Pass a received IP packet to tcpip_thread for input processing
+ * Pass a received packet to tcpip_thread for input processing
*
- * @param p the recevied packet, p->payload pointing to the IP header
- * @param netif the network interface on which the packet was received
+ * @param p the received packet, p->payload pointing to the Ethernet header or
+ * to an IP header (if inp doesn't have NETIF_FLAG_ETHARP or
+ * NETIF_FLAG_ETHERNET flags)
+ * @param inp the network interface on which the packet was received
*/
err_t
tcpip_input(struct pbuf *p, struct netif *inp)
{
- struct tcpip_msg *msg;
-
- if (mbox != SYS_MBOX_NULL) {
- msg = memp_malloc(MEMP_TCPIP_MSG_INPKT);
- if (msg == NULL) {
- return ERR_MEM;
- }
-
- msg->type = TCPIP_MSG_INPKT;
- msg->msg.inp.f = ip_input;
- msg->msg.inp.p = p;
- msg->msg.inp.netif = inp;
- sys_mbox_post(mbox, msg);
- return ERR_OK;
+#if LWIP_TCPIP_CORE_LOCKING_INPUT
+ err_t ret;
+ LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_input: PACKET %p/%p\n", (void *)p, (void *)inp));
+ LOCK_TCPIP_CORE();
+#if LWIP_ETHERNET
+ if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {
+ ret = ethernet_input(p, inp);
+ } else
+#endif /* LWIP_ETHERNET */
+ {
+ ret = ip_input(p, inp);
}
- return ERR_VAL;
-}
-
-err_t
-tcpip_input_callback(struct pbuf *p, struct netif *inp, err_t (*f)(struct pbuf *, struct netif *))
-{
+ UNLOCK_TCPIP_CORE();
+ return ret;
+#else /* LWIP_TCPIP_CORE_LOCKING_INPUT */
struct tcpip_msg *msg;
- if (mbox != SYS_MBOX_NULL) {
- msg = memp_malloc(MEMP_TCPIP_MSG_INPKT);
- if (msg == NULL) {
- return ERR_MEM;
- }
-
- msg->type = TCPIP_MSG_INPKT;
- msg->msg.inp.f = f;
- msg->msg.inp.p = p;
- msg->msg.inp.netif = inp;
- sys_mbox_post(mbox, msg);
- return ERR_OK;
+ if (!sys_mbox_valid(&mbox)) {
+ return ERR_VAL;
+ }
+ msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_INPKT);
+ if (msg == NULL) {
+ return ERR_MEM;
}
- return ERR_VAL;
-}
-#endif /* ETHARP_TCPIP_INPUT */
-#if ETHARP_TCPIP_ETHINPUT
-/**
- * Pass a received IP packet to tcpip_thread for input processing
- *
- * @param p the recevied packet, p->payload pointing to the ethernet header
- * @param netif the network interface on which the packet was received
- */
-err_t
-tcpip_ethinput(struct pbuf *p, struct netif *inp)
-{
- return tcpip_input_callback(p, inp, ethernet_input);
+ msg->type = TCPIP_MSG_INPKT;
+ msg->msg.inp.p = p;
+ msg->msg.inp.netif = inp;
+ if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {
+ memp_free(MEMP_TCPIP_MSG_INPKT, msg);
+ return ERR_MEM;
+ }
+ return ERR_OK;
+#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
}
-#endif /* ETHARP_TCPIP_ETHINPUT */
/**
* Call a specific function in the thread context of
*
* @param f the function to call
* @param ctx parameter passed to f
+ * @param block 1 to block until the request is posted, 0 to non-blocking mode
* @return ERR_OK if the function was called, another err_t if not
*/
err_t
-tcpip_callback(void (*f)(void *ctx), void *ctx)
+tcpip_callback_with_block(tcpip_callback_fn function, void *ctx, u8_t block)
{
struct tcpip_msg *msg;
- if (mbox != SYS_MBOX_NULL) {
- msg = memp_malloc(MEMP_TCPIP_MSG_API);
+ if (sys_mbox_valid(&mbox)) {
+ msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API);
if (msg == NULL) {
return ERR_MEM;
}
msg->type = TCPIP_MSG_CALLBACK;
- msg->msg.cb.f = f;
+ msg->msg.cb.function = function;
msg->msg.cb.ctx = ctx;
- sys_mbox_post(mbox, msg);
+ if (block) {
+ sys_mbox_post(&mbox, msg);
+ } else {
+ if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {
+ memp_free(MEMP_TCPIP_MSG_API, msg);
+ return ERR_MEM;
+ }
+ }
return ERR_OK;
}
return ERR_VAL;
}
+#if LWIP_TCPIP_TIMEOUT
+/**
+ * call sys_timeout in tcpip_thread
+ *
+ * @param msec time in milliseconds for timeout
+ * @param h function to be called on timeout
+ * @param arg argument to pass to timeout function h
+ * @return ERR_MEM on memory error, ERR_OK otherwise
+ */
err_t
tcpip_timeout(u32_t msecs, sys_timeout_handler h, void *arg)
{
struct tcpip_msg *msg;
- if (mbox != SYS_MBOX_NULL) {
- msg = memp_malloc(MEMP_TCPIP_MSG_API);
+ if (sys_mbox_valid(&mbox)) {
+ msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API);
if (msg == NULL) {
return ERR_MEM;
}
msg->msg.tmo.msecs = msecs;
msg->msg.tmo.h = h;
msg->msg.tmo.arg = arg;
- sys_mbox_post(mbox, msg);
+ sys_mbox_post(&mbox, msg);
+ return ERR_OK;
+ }
+ return ERR_VAL;
+}
+
+/**
+ * call sys_untimeout in tcpip_thread
+ *
+ * @param msec time in milliseconds for timeout
+ * @param h function to be called on timeout
+ * @param arg argument to pass to timeout function h
+ * @return ERR_MEM on memory error, ERR_OK otherwise
+ */
+err_t
+tcpip_untimeout(sys_timeout_handler h, void *arg)
+{
+ struct tcpip_msg *msg;
+
+ if (sys_mbox_valid(&mbox)) {
+ msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API);
+ if (msg == NULL) {
+ return ERR_MEM;
+ }
+
+ msg->type = TCPIP_MSG_UNTIMEOUT;
+ msg->msg.tmo.h = h;
+ msg->msg.tmo.arg = arg;
+ sys_mbox_post(&mbox, msg);
return ERR_OK;
}
return ERR_VAL;
}
+#endif /* LWIP_TCPIP_TIMEOUT */
+#if LWIP_NETCONN
/**
* Call the lower part of a netconn_* function
* This function is then running in the thread context
tcpip_apimsg(struct api_msg *apimsg)
{
struct tcpip_msg msg;
+#ifdef LWIP_DEBUG
+ /* catch functions that don't set err */
+ apimsg->msg.err = ERR_VAL;
+#endif
- if (mbox != SYS_MBOX_NULL) {
+ if (sys_mbox_valid(&mbox)) {
msg.type = TCPIP_MSG_API;
msg.msg.apimsg = apimsg;
- sys_mbox_post(mbox, &msg);
- sys_arch_mbox_fetch(apimsg->msg.conn->mbox, NULL, 0);
- return ERR_OK;
+ sys_mbox_post(&mbox, &msg);
+ sys_arch_sem_wait(&apimsg->msg.conn->op_completed, 0);
+ return apimsg->msg.err;
}
return ERR_VAL;
}
-#if LWIP_TCPIP_CORE_LOCKING
-/**
- * Call the lower part of a netconn_* function
- * This function has exclusive access to lwIP core code by locking it
- * before the function is called.
- *
- * @param apimsg a struct containing the function to call and its parameters
- * @return ERR_OK (only for compatibility fo tcpip_apimsg())
- */
-err_t
-tcpip_apimsg_lock(struct api_msg *apimsg)
-{
- LOCK_TCPIP_CORE();
- apimsg->function(&(apimsg->msg));
- UNLOCK_TCPIP_CORE();
- return ERR_OK;
-
-}
-#endif /* LWIP_TCPIP_CORE_LOCKING */
+#endif /* LWIP_NETCONN */
#if LWIP_NETIF_API
#if !LWIP_TCPIP_CORE_LOCKING
{
struct tcpip_msg msg;
- if (mbox != SYS_MBOX_NULL) {
- netifapimsg->msg.sem = sys_sem_new(0);
- if (netifapimsg->msg.sem == SYS_SEM_NULL) {
- netifapimsg->msg.err = ERR_MEM;
- return netifapimsg->msg.err;
+ if (sys_mbox_valid(&mbox)) {
+ err_t err = sys_sem_new(&netifapimsg->msg.sem, 0);
+ if (err != ERR_OK) {
+ netifapimsg->msg.err = err;
+ return err;
}
msg.type = TCPIP_MSG_NETIFAPI;
msg.msg.netifapimsg = netifapimsg;
- sys_mbox_post(mbox, &msg);
- sys_sem_wait(netifapimsg->msg.sem);
- sys_sem_free(netifapimsg->msg.sem);
+ sys_mbox_post(&mbox, &msg);
+ sys_sem_wait(&netifapimsg->msg.sem);
+ sys_sem_free(&netifapimsg->msg.sem);
return netifapimsg->msg.err;
}
return ERR_VAL;
#endif /* !LWIP_TCPIP_CORE_LOCKING */
#endif /* LWIP_NETIF_API */
+/**
+ * Allocate a structure for a static callback message and initialize it.
+ * This is intended to be used to send "static" messages from interrupt context.
+ *
+ * @param function the function to call
+ * @param ctx parameter passed to function
+ * @return a struct pointer to pass to tcpip_trycallback().
+ */
+struct tcpip_callback_msg* tcpip_callbackmsg_new(tcpip_callback_fn function, void *ctx)
+{
+ struct tcpip_msg *msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API);
+ if (msg == NULL) {
+ return NULL;
+ }
+ msg->type = TCPIP_MSG_CALLBACK_STATIC;
+ msg->msg.cb.function = function;
+ msg->msg.cb.ctx = ctx;
+ return (struct tcpip_callback_msg*)msg;
+}
+
+/**
+ * Free a callback message allocated by tcpip_callbackmsg_new().
+ *
+ * @param msg the message to free
+ */
+void tcpip_callbackmsg_delete(struct tcpip_callback_msg* msg)
+{
+ memp_free(MEMP_TCPIP_MSG_API, msg);
+}
+
+/**
+ * Try to post a callback-message to the tcpip_thread mbox
+ * This is intended to be used to send "static" messages from interrupt context.
+ *
+ * @param msg pointer to the message to post
+ * @return sys_mbox_trypost() return code
+ */
+err_t
+tcpip_trycallback(struct tcpip_callback_msg* msg)
+{
+ if (!sys_mbox_valid(&mbox)) {
+ return ERR_VAL;
+ }
+ return sys_mbox_trypost(&mbox, msg);
+}
+
/**
* Initialize this module:
- * - initialize ARP, IP, UDP and TCP
+ * - initialize all sub modules
* - start the tcpip_thread
*
- * @param initfunc a function to call when tcpip_thread is running and
- * finished initializing
+ * @param initfunc a function to call when tcpip_thread is running and finished initializing
* @param arg argument to pass to initfunc
*/
void
-tcpip_init(void (* initfunc)(void *), void *arg)
+tcpip_init(tcpip_init_done_fn initfunc, void *arg)
{
-#if LWIP_ARP
- etharp_init();
-#endif /* LWIP_ARP */
- ip_init();
-#if LWIP_RAW
- raw_init();
-#endif /* LWIP_RAW */
-#if LWIP_UDP
- udp_init();
-#endif /* LWIP_UDP */
-#if LWIP_TCP
- tcp_init();
-#endif /* LWIP_TCP */
-#if LWIP_AUTOIP
- autoip_init();
-#endif /* LWIP_AUTOIP */
+ lwip_init();
tcpip_init_done = initfunc;
tcpip_init_done_arg = arg;
- mbox = sys_mbox_new();
+ if(sys_mbox_new(&mbox, TCPIP_MBOX_SIZE) != ERR_OK) {
+ LWIP_ASSERT("failed to create tcpip_thread mbox", 0);
+ }
#if LWIP_TCPIP_CORE_LOCKING
- lock_tcpip_core = sys_sem_new(1);
+ if(sys_mutex_new(&lock_tcpip_core) != ERR_OK) {
+ LWIP_ASSERT("failed to create lock_tcpip_core", 0);
+ }
#endif /* LWIP_TCPIP_CORE_LOCKING */
- sys_thread_new(tcpip_thread, NULL, TCPIP_THREAD_PRIO);
+ sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO);
+}
+
+/**
+ * Simple callback function used with tcpip_callback to free a pbuf
+ * (pbuf_free has a wrong signature for tcpip_callback)
+ *
+ * @param p The pbuf (chain) to be dereferenced.
+ */
+static void
+pbuf_free_int(void *p)
+{
+ struct pbuf *q = (struct pbuf *)p;
+ pbuf_free(q);
+}
+
+/**
+ * A simple wrapper function that allows you to free a pbuf from interrupt context.
+ *
+ * @param p The pbuf (chain) to be dereferenced.
+ * @return ERR_OK if callback could be enqueued, an err_t if not
+ */
+err_t
+pbuf_free_callback(struct pbuf *p)
+{
+ return tcpip_callback_with_block(pbuf_free_int, p, 0);
+}
+
+/**
+ * A simple wrapper function that allows you to free heap memory from
+ * interrupt context.
+ *
+ * @param m the heap memory to free
+ * @return ERR_OK if callback could be enqueued, an err_t if not
+ */
+err_t
+mem_free_callback(void *m)
+{
+ return tcpip_callback_with_block(vPortFree, m, 0);
}
#endif /* !NO_SYS */
projects / pes-rpp / rpp-lwip.git / blobdiff