Subversion Repositories openrisc

/**

 * @file

 * Sequential API Main thread module

 *

 */

/*

 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without modification,

 * are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. 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.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.

 *

 * This file is part of the lwIP TCP/IP stack.

 *

 * Author: Adam Dunkels <adam@sics.se>

 *

 */

#include "lwip/opt.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/pbuf.h"

#include "lwip/ip_frag.h"

#include "lwip/tcp.h"

#include "lwip/autoip.h"

#include "lwip/dhcp.h"

#include "lwip/igmp.h"

#include "lwip/dns.h"

#include "lwip/tcpip.h"

#include "lwip/init.h"

#include "netif/etharp.h"

#include "netif/ppp_oe.h"

/* global variables */

static void (* tcpip_init_done)(void *arg);

static void *tcpip_init_done_arg;

static sys_mbox_t mbox = SYS_MBOX_NULL;

#if LWIP_TCPIP_CORE_LOCKING

/** The global semaphore to lock the stack. */

sys_sem_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;

/**

 * 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_MSECS, 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 LWIP_DNS

/**

 * Timer callback function that calls dns_tmr() and reschedules itself.

 *

 * @param arg unused argument

 */

static void

dns_timer(void *arg)

{

  LWIP_UNUSED_ARG(arg);

  LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip: dns_tmr()\n"));

  dns_tmr();

  sys_timeout(DNS_TMR_INTERVAL, dns_timer, NULL);

}

#endif /* LWIP_DNS */

/**

 * The main lwIP thread. This thread has exclusive access to lwIP core functions

 * (unless access to them is not locked). Other threads communicate with this

 * thread using message boxes.

 *

 * It also starts all the timers to make sure they are running in the right

 * thread context.

 *

 * @param arg unused argument

 */

static void

tcpip_thread(void *arg)

{

  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_MSECS, 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 LWIP_IGMP

  sys_timeout(IGMP_TMR_INTERVAL, igmp_timer, NULL);

#endif /* LWIP_IGMP */

#if LWIP_DNS

  sys_timeout(DNS_TMR_INTERVAL, dns_timer, NULL);

#endif /* LWIP_DNS */

  if (tcpip_init_done != NULL) {

    tcpip_init_done(tcpip_init_done_arg);

  }

  LOCK_TCPIP_CORE();

  while (1) {                          /* MAIN Loop */

    sys_mbox_fetch(mbox, (void *)&msg);

    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 */

    case TCPIP_MSG_INPKT:

      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));

#if LWIP_ARP

      if (msg->msg.inp.netif->flags & NETIF_FLAG_ETHARP) {

        ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);

      } else

#endif /* LWIP_ARP */

      { ip_input(msg->msg.inp.p, msg->msg.inp.netif);

      }

      memp_free(MEMP_TCPIP_MSG_INPKT, msg);

      break;

#if LWIP_NETIF_API

    case TCPIP_MSG_NETIFAPI:

      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: Netif API message %p\n", (void *)msg));

      msg->msg.netifapimsg->function(&(msg->msg.netifapimsg->msg));

      break;

#endif /* LWIP_NETIF_API */

    case TCPIP_MSG_CALLBACK:

      LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));

      msg->msg.cb.f(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));

      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;

    default:

      break;

    }

  }

}

/**

 * Pass a received packet to tcpip_thread for input processing

 *

 * @param p the received packet, p->payload pointing to the Ethernet header or

 *          to an IP header (if netif doesn't got NETIF_FLAG_ETHARP flag)

 * @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.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;

  }

  return ERR_VAL;

}

/**

 * Call a specific function in the thread context of

 * tcpip_thread for easy access synchronization.

 * A function called in that way may access lwIP core code

 * without fearing concurrent access.

 *

 * @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_with_block(void (*f)(void *ctx), void *ctx, u8_t block)

{

  struct tcpip_msg *msg;

  if (mbox != SYS_MBOX_NULL) {

    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.ctx = ctx;

    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;

}

/**

 * call sys_timeout in tcpip_thread

 *

 * @param msec time in miliseconds 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 (msg == NULL) {

      return ERR_MEM;

    }

    msg->type = TCPIP_MSG_TIMEOUT;

    msg->msg.tmo.msecs = msecs;

    msg->msg.tmo.h = h;

    msg->msg.tmo.arg = arg;

    sys_mbox_post(mbox, msg);

    return ERR_OK;

  }

  return ERR_VAL;

}

/**

 * call sys_untimeout in tcpip_thread

 *

 * @param msec time in miliseconds 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 (mbox != SYS_MBOX_NULL) {

    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;

}

#if LWIP_NETCONN

/**

 * Call the lower part of a netconn_* function

 * This function is then running in the thread context

 * of tcpip_thread and has exclusive access to lwIP core code.

 *

 * @param apimsg a struct containing the function to call and its parameters

 * @return ERR_OK if the function was called, another err_t if not

 */

err_t

tcpip_apimsg(struct api_msg *apimsg)

{

  struct tcpip_msg msg;

  if (mbox != SYS_MBOX_NULL) {

    msg.type = TCPIP_MSG_API;

    msg.msg.apimsg = apimsg;

    sys_mbox_post(mbox, &msg);

    sys_arch_sem_wait(apimsg->msg.conn->op_completed, 0);

    return ERR_OK;

  }

  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

/**

 * Much like tcpip_apimsg, but calls the lower part of a netifapi_*

 * function.

 *

 * @param netifapimsg a struct containing the function to call and its parameters

 * @return error code given back by the function that was called

 */

err_t

tcpip_netifapi(struct netifapi_msg* netifapimsg)

{

  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;

    }

    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);

    return netifapimsg->msg.err;

  }

  return ERR_VAL;

}

#else /* !LWIP_TCPIP_CORE_LOCKING */

/**

 * Call the lower part of a netifapi_* function

 * This function has exclusive access to lwIP core code by locking it

 * before the function is called.

 *

 * @param netifapimsg a struct containing the function to call and its parameters

 * @return ERR_OK (only for compatibility fo tcpip_netifapi())

 */

err_t

tcpip_netifapi_lock(struct netifapi_msg* netifapimsg)

{

  LOCK_TCPIP_CORE();

  netifapimsg->function(&(netifapimsg->msg));

  UNLOCK_TCPIP_CORE();

  return netifapimsg->msg.err;

}

#endif /* !LWIP_TCPIP_CORE_LOCKING */

#endif /* LWIP_NETIF_API */

/**

 * Initialize this module:

 * - initialize all sub modules

 * - start the tcpip_thread

 *

 * @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)

{

  lwip_init();

  tcpip_init_done = initfunc;

  tcpip_init_done_arg = arg;

  mbox = sys_mbox_new(TCPIP_MBOX_SIZE);

#if LWIP_TCPIP_CORE_LOCKING

  lock_tcpip_core = sys_sem_new(1);

#endif /* LWIP_TCPIP_CORE_LOCKING */

  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 = 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(mem_free, m, 0);

}

#endif /* !NO_SYS */