From 95317af605c883b464a4c5b524632193614bfd24 Mon Sep 17 00:00:00 2001 From: patacongo Date: Sat, 12 Mar 2011 03:42:08 +0000 Subject: Add SLIP driver git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@3369 42af7a65-404d-4744-a932-0658087f49c3 --- nuttx/ChangeLog | 8 + nuttx/Documentation/NuttX.html | 8 + nuttx/drivers/net/Make.defs | 3 + nuttx/drivers/net/slip.c | 992 +++++++++++++++++++++++++++++++++++++++++ nuttx/include/nuttx/net.h | 9 +- nuttx/include/nuttx/sched.h | 13 +- nuttx/sched/atexit.c | 20 +- nuttx/sched/exit.c | 10 +- 8 files changed, 1051 insertions(+), 12 deletions(-) create mode 100644 nuttx/drivers/net/slip.c diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog index 0306a28de..75062412c 100644 --- a/nuttx/ChangeLog +++ b/nuttx/ChangeLog @@ -1542,3 +1542,11 @@ But, during development, you might want to have you applications available and executable from the NSH command line. This apps/ addon (and NSH hooks) was contributed by Uros to accomplish just that. + * sched/sched_waitpid() and include/sys/wait.h - Provides a simple and + very incomplete implementation of waitpid(). waitpid() is only available + if CONFIG_SCHED_WAITPID is defined in your configuration file. + * sched/atexit.c and sched/exit.c - The atexit function is not frequently + used. In order to save a few bytes, it is now conditioned on + CONFIG_SCHED_ATEXIT. It your application is currently using atexit(), + you will need to add CONFIG_SCHED_ATEXT to your configuration file. + * drivers/net/slip.c - Add a SLIP driver (untested on initial check-in). diff --git a/nuttx/Documentation/NuttX.html b/nuttx/Documentation/NuttX.html index a3763dcef..a110d5ff2 100644 --- a/nuttx/Documentation/NuttX.html +++ b/nuttx/Documentation/NuttX.html @@ -2166,6 +2166,14 @@ nuttx-5.19 2011-xx-xx Gregory Nutt <spudmonkey@racsa.co.cr> But, during development, you might want to have you applications available and executable from the NSH command line. This apps/ addon (and NSH hooks) was contributed by Uros to accomplish just that. + * sched/sched_waitpid() and include/sys/wait.h - Provides a simple and + very incomplete implementation of waitpid(). waitpid() is only available + if CONFIG_SCHED_WAITPID is defined in your configuration file. + * sched/atexit.c and sched/exit.c - The atexit function is not frequently + used. In order to save a few bytes, it is now conditioned on + CONFIG_SCHED_ATEXIT. It your application is currently using atexit(), + you will need to add CONFIG_SCHED_ATEXT to your configuration file. + * drivers/net/slip.c - Add a SLIP driver (untested on initial check-in). pascal-2.1 2011-xx-xx Gregory Nutt <spudmonkey@racsa.co.cr> diff --git a/nuttx/drivers/net/Make.defs b/nuttx/drivers/net/Make.defs index 06c3181f4..244fe4cd7 100644 --- a/nuttx/drivers/net/Make.defs +++ b/nuttx/drivers/net/Make.defs @@ -46,5 +46,8 @@ endif ifeq ($(CONFIG_NET_ENC28J60),y) NET_CSRCS += enc28j60.c endif +ifeq ($(CONFIG_NET_SLIP),y) +NET_CSRCS += slip.c +endif endif diff --git a/nuttx/drivers/net/slip.c b/nuttx/drivers/net/slip.c new file mode 100644 index 000000000..fab395b72 --- /dev/null +++ b/nuttx/drivers/net/slip.c @@ -0,0 +1,992 @@ +/**************************************************************************** + * drivers/net/slip.c + * + * Copyright (C) 2010 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Reference: RFC 1055 + * + * 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. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "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 + * COPYRIGHT OWNER OR CONTRIBUTORS 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. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include + +#if defined(CONFIG_NET) && defined(CONFIG_NET_SLIP) + +/**************************************************************************** + * Pre-processor Definitions + ****************************************************************************/ + +/* Configuration ************************************************************/ + +#if UIP_LLH_LEN > 0 +# error "CONFIG_NET_LLH_LEN must be set to zero" +#endif + +#ifndef CONFIG_SLIP_STACKSIZE +# define CONFIG_SLIP_STACKSIZE 1024 +#endif + +#ifndef CONFIG_SLIP_DEFPRIO +# define CONFIG_SLIP_DEFPRIO 128 +#endif + +/* SLIP special character codes *******************************************/ + +#define SLIP_END 0300 /* Indicates end of packet */ +#define SLIP_ESC 0333 /* Indicates byte stuffing */ +#define SLIP_ESC_END 0334 /* ESC ESC_END means SLIP_END data byte */ +#define SLIP_ESC_ESC 0335 /* ESC ESC_ESC means ESC data byte */ + +/* General driver definitions **********************************************/ + +/* CONFIG_SLIP_NINTERFACES determines the number of physical interfaces + * that will be supported. + */ + +#ifndef CONFIG_SLIP_NINTERFACES +# define CONFIG_SLIP_NINTERFACES 1 +#endif + +/* TX poll deley = 1 seconds. CLK_TCK is the number of clock ticks per second */ + +#define SLIP_WDDELAY (1*CLK_TCK) +#define SLIP_POLLHSEC (1*2) + +/* TX timeout = 1 minute */ + +#define SLIP_TXTIMEOUT (60*CLK_TCK) + +/* Statistics helper */ + +#ifdef CONFIG_NET_STATISTICS +# define SLIP_STAT(p,f) (p->stats.f)++ +#else +# define SLIP_STAT(p,f) +#endif + +/* This is a helper pointer for accessing the contents of the Ethernet header */ + +#define BUF ((struct uip_eth_hdr *)priv->dev.d_buf) + +/**************************************************************************** + * Private Types + ****************************************************************************/ + +/* Driver statistics */ + +#ifdef CONFIG_NET_STATISTICS +struct slip_statistics_s +{ + uint32_t transmitted; /* Number of packets transmitted */ + /* Number of packets received is the sum of: */ + uint32_t rxip; /* Number of IP packets received */ + uint32_t rxarp; /* + Number of ARP packets received */ + uint32_t rxproto; /* + Number of unsupported packets received */ +}; +#endif + +/* The slip_driver_s encapsulates all state information for a single hardware + * interface + */ + +struct slip_driver_s +{ + bool bifup; /* true:ifup false:ifdown */ + WDOG_ID txpoll; /* TX poll timer */ + int fd; /* File descriptor associated with stream */ + FILE *stream; /* The contained serial stream */ + sem_t waitsem; /* Only used at start-up */ + + /* Driver statistics */ + +#ifdef CONFIG_NET_STATISTICS + struct slip_statistics_s stats; +#endif + + /* This holds the information visible to uIP/NuttX */ + + struct uip_driver_s dev; /* Interface understood by uIP */ +}; + +/**************************************************************************** + * Private Data + ****************************************************************************/ + + /* We really should get rid of CONFIG_SLIP_NINTERFACES and, instead, + * malloc() new interface instances as needed. + */ + +static struct slip_driver_s g_slip[CONFIG_SLIP_NINTERFACES]; + +/**************************************************************************** + * Private Function Prototypes + ****************************************************************************/ + +static void slip_semtake(FAR struct slip_driver_s *priv); + +/* Common TX logic */ + +static inline void slip_write(FAR struct slip_driver_s *priv, + const uint8_t *buffer, int len); +static inline void slip_putc(FAR struct slip_driver_s *priv, int ch); +static int slip_transmit(FAR struct slip_driver_s *priv); +static int slip_uiptxpoll(struct uip_driver_s *dev); + +/* Interrupt handling */ + +static inline int slip_getc(FAR struct slip_driver_s *priv); +static inline void slip_readpacket(FAR struct slip_driver_s *priv); +static void slip_receive(FAR struct slip_driver_s *priv); +static int slip_rxtask(int argc, char *argv[]); + +/* Watchdog timer expirations */ + +static void slip_polltimer(int argc, uint32_t arg, ...); + +/* NuttX callback functions */ + +static int slip_ifup(struct uip_driver_s *dev); +static int slip_ifdown(struct uip_driver_s *dev); +static int slip_txavail(struct uip_driver_s *dev); +#ifdef CONFIG_NET_IGMP +static int slip_addmac(struct uip_driver_s *dev, FAR const uint8_t *mac); +static int slip_rmmac(struct uip_driver_s *dev, FAR const uint8_t *mac); +#endif + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: slip_semtake + ****************************************************************************/ + +static void slip_semtake(FAR struct slip_driver_s *priv) +{ + /* Take the semaphore (perhaps waiting) */ + + while (sem_wait(&priv->waitsem) != 0) + { + /* The only case that an error should occur here is if + * the wait was awakened by a signal. + */ + + ASSERT(errno == EINTR); + } +} + +#define slip_semgive(p) sem_post(&(p)->waitsem); + +/**************************************************************************** + * Function: slip_write + * + * Description: + * Just an inline wrapper around fwrite with error checking. + * + * Parameters: + * priv - Reference to the driver state structure + * buffer - Buffer data to send + * len - Buffer length in bytes + * + ****************************************************************************/ + +static inline void slip_write(FAR struct slip_driver_s *priv, + const uint8_t *buffer, int len) +{ +#if CONFIG_DEBUG + size_t nbytes = fwrite(buffer, 1, len, priv->stream); + DEBUGASSERT(nbytes == len); +#else + (void)fwrite(buffer, 1, len, priv->stream); +#endif +} + +/**************************************************************************** + * Function: slip_putc + * + * Description: + * Just an inline wrapper around putc with error checking. + * + * Parameters: + * priv - Reference to the driver state structure + * ch - The character to send + * + ****************************************************************************/ + +static inline void slip_putc(FAR struct slip_driver_s *priv, int ch) +{ +#if CONFIG_DEBUG + int ret = putc(ch, priv->stream); + DEBUGASSERT(ret == ch); +#else + putc(ch, priv->stream); +#endif +} + +/**************************************************************************** + * Function: slip_transmit + * + * Description: + * Start hardware transmission. Called either from the txdone interrupt + * handling or from watchdog based polling. + * + * Parameters: + * priv - Reference to the driver state structure + * + * Returned Value: + * OK on success; a negated errno on failure + * + * Assumptions: + * May or may not be called from an interrupt handler. In either case, + * global interrupts are disabled, either explicitly or indirectly through + * interrupt handling logic. + * + ****************************************************************************/ + +static int slip_transmit(FAR struct slip_driver_s *priv) +{ + uint8_t *src; + uint8_t *start; + uint8_t esc; + int remaining; + int len; + + /* Increment statistics */ + + SLIP_STAT(priv, transmitted); + + /* Send an initial END character to flush out any data that may have + * accumulated in the receiver due to line noise + */ + + slip_putc(priv, SLIP_END); + + /* For each byte in the packet, send the appropriate character sequence */ + + src = priv->dev.d_buf; + remaining = priv->dev.d_len; + start = src; + + while (remaining-- > 0) + { + switch (*src) + { + /* If it's the same code as an END character, we send a special two + * character code so as not to make the receiver think we sent an + * END + */ + + case SLIP_END: + esc = SLIP_ESC_END; + goto escape; + + /* if it's the same code as an ESC character, we send a special two + * character code so as not to make the receiver think we sent an + * ESC + */ + + case SLIP_ESC: + esc = SLIP_ESC_ESC; + + escape: + { + /* Flush any unsent data */ + + if (len > 0) + { + slip_write(priv, start, len); + + /* Reset */ + + start = src + 1; + len = 0; + } + + /* Then send the escape sequence */ + + slip_putc(priv, SLIP_ESC); + slip_putc(priv, esc); + } + break; + + /* otherwise, just bump up the count */ + + default: + len++; + break; + } + + /* Point to the next character in the packet */ + + src++; + } + + /* We have looked at every charcter in the packet. Now flush any unsent + * data + */ + + if (len > 0) + { + slip_write(priv, start, len); + } + + /* And send the END token */ + + slip_putc(priv, SLIP_END); + return OK; +} + +/**************************************************************************** + * Function: slip_uiptxpoll + * + * Description: + * The transmitter is available, check if uIP has any outgoing packets ready + * to send. This is a callback from uip_poll(). uip_poll() may be called: + * + * 1. When the preceding TX packet send is complete, + * 2. When the preceding TX packet send timesout and the interface is reset + * 3. During normal TX polling + * + * Parameters: + * dev - Reference to the NuttX driver state structure + * + * Returned Value: + * OK on success; a negated errno on failure + * + * Assumptions: + * May or may not be called from an interrupt handler. In either case, + * global interrupts are disabled, either explicitly or indirectly through + * interrupt handling logic. + * + ****************************************************************************/ + +static int slip_uiptxpoll(struct uip_driver_s *dev) +{ + FAR struct slip_driver_s *priv = (FAR struct slip_driver_s *)dev->d_private; + + /* If the polling resulted in data that should be sent out on the network, + * the field d_len is set to a value > 0. + */ + + if (priv->dev.d_len > 0) + { + uip_arp_out(&priv->dev); + slip_transmit(priv); + } + + /* If zero is returned, the polling will continue until all connections have + * been examined. + */ + + return 0; +} + +/**************************************************************************** + * Function: slip_getc + * + * Description: + * Get one byte from the serial input. + * + * Parameters: + * priv - Reference to the driver state structure + * + * Returned Value: + * The returned byte + * + ****************************************************************************/ + +static inline int slip_getc(FAR struct slip_driver_s *priv) +{ + int ret = getc(priv->stream); + DEBUGASSERT(ret != EOF); + return ret; +} + +/**************************************************************************** + * Function: slip_readpacket + * + * Description: + * Read a packet from the serial input + * + * Parameters: + * priv - Reference to the driver state structure + * + * Returned Value: + * None + * + ****************************************************************************/ + +static inline void slip_readpacket(FAR struct slip_driver_s *priv) +{ + uint8_t ch; + int nbytes = 0; + + /* Copy the data data from the hardware to priv->dev.d_buf until we + * put together a whole packet. Make sure not to copy them into the + * packet if we run out of room. + */ + + for (;;) + { + /* Get the next character in the stream */ + + ch = slip_getc(priv); + + /* Handle bytestuffing if necessary */ + + switch (ch) + { + /* If it's an END character then we're done with the packet. + * (OR we are just starting a packet) + */ + + case SLIP_END: + /* a minor optimization: if there is no data in the packet, ignore + * it. This is meant to avoid bothering IP with all the empty + * packets generated by the duplicate END characters which are in + * turn sent to try to detect line noise. + */ + + if (nbytes > 0) + { + priv->dev.d_len = nbytes; + return; + } + break; + + /* if it's the same code as an ESC character, wait and get another + * character and then figure out what to store in the packet based + * on that. + */ + + case SLIP_ESC: + ch = slip_getc(priv); + + /* if "ch" is not one of these two, then we have a protocol + * violation. The best bet seems to be to leave the byte alone + * and just stuff it into the packet + */ + + switch (ch) + { + case SLIP_ESC_END: + ch = SLIP_END; + break; + case SLIP_ESC_ESC: + ch = SLIP_ESC; + break; + default: + ndbg("ERROR: Protocol violation: %02x\n", ch); + break; + } + + /* Here we fall into the default handler and let it store the + * character for us + */ + + default: + if (nbytes < priv->dev.d_len) + { + priv->dev.d_buf[nbytes++] = ch; + } + break; + } + } +} + +/**************************************************************************** + * Function: slip_receive + * + * Description: + * Accept and handle an incoming packet. + * + * Parameters: + * priv - Reference to the driver state structure + * + * Returned Value: + * None + * + * Assumptions: + * Global interrupts are disabled by interrupt handling logic. + * + ****************************************************************************/ + +static void slip_receive(FAR struct slip_driver_s *priv) +{ + /* Copy the data data from the hardware to priv->dev.d_buf until we put + * together a whole packet. + */ + + slip_readpacket(priv); + + /* We only accept IP packets of the configured type and ARP packets */ + +#ifdef CONFIG_NET_IPv6 + if (BUF->type == HTONS(UIP_ETHTYPE_IP6)) +#else + if (BUF->type == HTONS(UIP_ETHTYPE_IP)) +#endif + { + SLIP_STAT(priv, rxip); + uip_arp_ipin(&priv->dev); + uip_input(&priv->dev); + + /* If the above function invocation resulted in data that should be + * sent out on the network, the field d_len will set to a value > 0. + */ + + if (priv->dev.d_len > 0) + { + uip_arp_out(&priv->dev); + slip_transmit(priv); + } + } + else if (BUF->type == htons(UIP_ETHTYPE_ARP)) + { + SLIP_STAT(priv, rxarp); + uip_arp_arpin(&priv->dev); + + /* If the above function invocation resulted in data that should be + * sent out on the network, the field d_len will set to a value > 0. + */ + + if (priv->dev.d_len > 0) + { + slip_transmit(priv); + } + } + else + { + SLIP_STAT(priv, rxproto); + } +} + +/**************************************************************************** + * Function: slip_rxtask + * + * Description: + * Wait for incoming data. + * + * Parameters: + * argc + * argv + * + * Returned Value: + * (Does not return) + * + * Assumptions: + * + ****************************************************************************/ + +static int slip_rxtask(int argc, char *argv[]) +{ + FAR struct slip_driver_s *priv; + struct pollfd fds[1]; + unsigned int index = *(argv[1]) - '0'; + irqstate_t flags; + int ret; + + ndbg("index: %d\n", index); + DEBUGASSERT(index < CONFIG_SLIP_NINTERFACES); + + /* Get our private data structure instance */ + + priv = &g_slip[index]; + slip_semgive(priv); + + /* Loop forever */ + + for (;;) + { + /* Set up the poll */ + + memset(fds, 0, sizeof(struct pollfd)); + fds[0].fd = priv->fd; + fds[0].events = POLLIN; + fds[0].revents = 0; + + /* Wait for incoming data (with no timeout) */ + + ret = poll(fds, 1, -1); + DEBUGASSERT(ret >= 0); + if (ret > 0) + { + /* Call slip_receive() to handle incoming data. Interrupts must + * be disabled here to keept the POLL watchdoe from firing. + */ + + flags = irqsave(); + slip_receive(priv); + irqrestore(flags); + } + } + + /* We won't get here */ + + return OK; +} + +/**************************************************************************** + * Function: slip_polltimer + * + * Description: + * Periodic timer handler. Called from the timer interrupt handler. + * + * Parameters: + * argc - The number of available arguments + * arg - The first argument + * + * Returned Value: + * None + * + * Assumptions: + * Global interrupts are disabled by the watchdog logic. + * + ****************************************************************************/ + +static void slip_polltimer(int argc, uint32_t arg, ...) +{ + FAR struct slip_driver_s *priv = (FAR struct slip_driver_s *)arg; + + /* If so, update TCP timing states and poll uIP for new XMIT data. */ + + (void)uip_timer(&priv->dev, slip_uiptxpoll, SLIP_POLLHSEC); + + /* Setup the watchdog poll timer again */ + + (void)wd_start(priv->txpoll, SLIP_WDDELAY, slip_polltimer, 1, arg); +} + +/**************************************************************************** + * Function: slip_ifup + * + * Description: + * NuttX Callback: Bring up the Ethernet interface when an IP address is + * provided + * + * Parameters: + * dev - Reference to the NuttX driver state structure + * + * Returned Value: + * None + * + * Assumptions: + * + ****************************************************************************/ + +static int slip_ifup(struct uip_driver_s *dev) +{ + FAR struct slip_driver_s *priv = (FAR struct slip_driver_s *)dev->d_private; + + ndbg("Bringing up: %d.%d.%d.%d\n", + dev->d_ipaddr & 0xff, (dev->d_ipaddr >> 8) & 0xff, + (dev->d_ipaddr >> 16) & 0xff, dev->d_ipaddr >> 24 ); + + /* Set and activate a timer process */ + + (void)wd_start(priv->txpoll, SLIP_WDDELAY, slip_polltimer, 1, (uint32_t)priv); + + /* Mark the interface up */ + + priv->bifup = true; + return OK; +} + +/**************************************************************************** + * Function: slip_ifdown + * + * Description: + * NuttX Callback: Stop the interface. + * + * Parameters: + * dev - Reference to the NuttX driver state structure + * + * Returned Value: + * None + * + * Assumptions: + * + ****************************************************************************/ + +static int slip_ifdown(struct uip_driver_s *dev) +{ + FAR struct slip_driver_s *priv = (FAR struct slip_driver_s *)dev->d_private; + irqstate_t flags; + + /* Disable the interrupts */ + + flags = irqsave(); + + /* Cancel the TX poll timer and TX timeout timers */ + + wd_cancel(priv->txpoll); + + /* Mark the device "down" */ + + priv->bifup = false; + irqrestore(flags); + return OK; +} + +/**************************************************************************** + * Function: slip_txavail + * + * Description: + * Driver callback invoked when new TX data is available. This is a + * stimulus perform an out-of-cycle poll and, thereby, reduce the TX + * latency. + * + * Parameters: + * dev - Reference to the NuttX driver state structure + * + * Returned Value: + * None + * + * Assumptions: + * Called in normal user mode + * + ****************************************************************************/ + +static int slip_txavail(struct uip_driver_s *dev) +{ + FAR struct slip_driver_s *priv = (FAR struct slip_driver_s *)dev->d_private; + irqstate_t flags; + + /* Disable interrupts because this function may be called from interrupt + * level processing. + */ + + flags = irqsave(); + + /* Ignore the notification if the interface is not yet up */ + + if (priv->bifup) + { + /* Poll uIP for new XMIT data */ + + (void)uip_poll(&priv->dev, slip_uiptxpoll); + } + + irqrestore(flags); + return OK; +} + +/**************************************************************************** + * Function: slip_addmac + * + * Description: + * NuttX Callback: Add the specified MAC address to the hardware multicast + * address filtering + * + * Parameters: + * dev - Reference to the NuttX driver state structure + * mac - The MAC address to be added + * + * Returned Value: + * None + * + * Assumptions: + * + ****************************************************************************/ + +#ifdef CONFIG_NET_IGMP +static int slip_addmac(struct uip_driver_s *dev, FAR const uint8_t *mac) +{ + FAR struct slip_driver_s *priv = (FAR struct slip_driver_s *)dev->d_private; + + /* Add the MAC address to the hardware multicast routing table */ + + return OK; +} +#endif + +/**************************************************************************** + * Function: slip_rmmac + * + * Description: + * NuttX Callback: Remove the specified MAC address from the hardware multicast + * address filtering + * + * Parameters: + * dev - Reference to the NuttX driver state structure + * mac - The MAC address to be removed + * + * Returned Value: + * None + * + * Assumptions: + * + ****************************************************************************/ + +#ifdef CONFIG_NET_IGMP +static int slip_rmmac(struct uip_driver_s *dev, FAR const uint8_t *mac) +{ + FAR struct slip_driver_s *priv = (FAR struct slip_driver_s *)dev->d_private; + + /* Add the MAC address to the hardware multicast routing table */ + + return OK; +} +#endif + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Function: slip_initialize + * + * Description: + * Instantiate a SLIP network interface. + * + * Parameters: + * intf - In the case where there are multiple SLIP interfaces, this value + * identifies which is to be initialized. The network name will be, + * for example, "/dev/slip5" for intf == 5 + * + * Returned Value: + * OK on success; Negated errno on failure. + * + * Assumptions: + * + ****************************************************************************/ + +int slip_initialize(int intf, const char *devname) +{ + struct slip_driver_s *priv; + char buffer[IFNAMSIZ]; + pid_t pid; + + /* Get the interface structure associated with this interface number. */ + + DEBUGASSERT(inf < CONFIG_SLIP_NINTERFACES); + priv = &g_slip[intf]; + + /* Initialize the driver structure */ + + memset(priv, 0, sizeof(struct slip_driver_s)); + priv->dev.d_ifup = slip_ifup; /* I/F down callback */ + priv->dev.d_ifdown = slip_ifdown; /* I/F up (new IP address) callback */ + priv->dev.d_txavail = slip_txavail; /* New TX data callback */ +#ifdef CONFIG_NET_IGMP + priv->dev.d_addmac = slip_addmac; /* Add multicast MAC address */ + priv->dev.d_rmmac = slip_rmmac; /* Remove multicast MAC address */ +#endif + priv->dev.d_private = priv; /* Used to recover private state from dev */ + + /* Open the device */ + + priv->fd = open(devname, O_RDWR, 0666); + if (priv->fd < 0) + { + ndbg("ERROR: Failed to open %s: %d\n", devname, errno); + return -errno; + } + + priv->stream = fdopen(priv->fd, "rw"); + if (priv->stream == NULL) + { + ndbg("ERROR: Failed to fdopen %s: %d\n", devname, errno); + close(priv->fd); + return -errno; + } + + /* Initialize the wait semaphore */ + + sem_init(&priv->waitsem, 0, 0); + + /* Put the interface in the down state. This usually amounts to resetting + * the device and/or calling slip_ifdown(). + */ + + slip_ifdown(&priv->dev); + + /* Start the SLIP receiver task */ + + snprintf(buffer, IFNAMSIZ, "%d", intf); + +#ifndef CONFIG_CUSTOM_STACK + pid = task_create("usbhost", CONFIG_SLIP_DEFPRIO, CONFIG_SLIP_STACKSIZE, + (main_t)slip_rxtask, (const char **)buffer); +#else + pid = task_create("usbhost", CONFIG_SLIP_DEFPRIO, + (main_t)slip_rxtask, (const char **)buffer); +#endif + if (pid < 0) + { + ndbg("ERROR: Failed to start receiver task\n"); + return -errno; + } + + /* Wait and make sure that the receive task is started. */ + + slip_semtake(priv); + + /* Create a watchdog for timing polling for and timing of transmisstions */ + + priv->txpoll = wd_create(); /* Create periodic poll timer */ + + /* Register the device with the OS so that socket IOCTLs can be performed */ + +#if CONFIG_NSOCKET_DESCRIPTORS > 0 + snprintf(buffer, IFNAMSIZ, "slip%d", intf); +#endif + (void)netdev_register(&priv->dev); + return OK; +} + +#endif /* CONFIG_NET && CONFIG_NET_SLIP */ + diff --git a/nuttx/include/nuttx/net.h b/nuttx/include/nuttx/net.h index d9b4e42b3..2294a38dc 100644 --- a/nuttx/include/nuttx/net.h +++ b/nuttx/include/nuttx/net.h @@ -1,7 +1,7 @@ /**************************************************************************** * nuttx/net.h * - * Copyright (C) 2007, 2009-2010 Gregory Nutt. All rights reserved. + * Copyright (C) 2007, 2009-2011 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -207,6 +207,13 @@ EXTERN int netdev_register(FAR struct uip_driver_s *dev); EXTERN int netdev_foreach(netdev_callback_t callback, void *arg); +/* drivers/net/slip.c ******************************************************/ +/* Instantiate a SLIP network interface. */ + +#ifdef CONFIG_NET_SLIP +EXTERN int slip_initialize(int intf, const char *devname); +#endif + #undef EXTERN #ifdef __cplusplus } diff --git a/nuttx/include/nuttx/sched.h b/nuttx/include/nuttx/sched.h index c5e061cb6..70c8a746a 100644 --- a/nuttx/include/nuttx/sched.h +++ b/nuttx/include/nuttx/sched.h @@ -118,8 +118,8 @@ typedef enum tstate_e tstate_t; typedef void (*start_t)(void); -/* This is the entry point into the main thread of the task - * or into a created pthread within the task. +/* This is the entry point into the main thread of the task or into a created + * pthread within the task. */ union entry_u @@ -129,17 +129,20 @@ union entry_u }; typedef union entry_u entry_t; -/* This is the type of the function that is executed with - * exit() is called (if registered via atexit()). +/* This is the type of the function that is executed with exit() is called + * (if registered via atexit()). */ +#ifdef CONFIG_SCHED_ATEXT typedef void (*exitfunc_t)(void); +#endif /* POSIX Message queue */ typedef struct msgq_s msgq_t; /* The structure used to maintain environment variables */ + #ifndef CONFIG_DISABLE_ENVIRON struct environ_s { @@ -177,7 +180,9 @@ struct _TCB pid_t pid; /* This is the ID of the thread */ start_t start; /* Thread start function */ entry_t entry; /* Entry Point into the thread */ +#ifdef CONFIG_SCHED_ATEXT exitfunc_t exitfunc; /* Called if exit is called. */ +#endif #ifdef CONFIG_SCHED_WAITPID /* Experimental */ sem_t exitsem; /* Support for waitpid */ int *stat_loc; /* Location to return exit status */ diff --git a/nuttx/sched/atexit.c b/nuttx/sched/atexit.c index 5ca6c5e0f..ca7ef58c4 100644 --- a/nuttx/sched/atexit.c +++ b/nuttx/sched/atexit.c @@ -1,7 +1,7 @@ /************************************************************************ * sched/atexit.c * - * Copyright (C) 2007, 2009 Gregory Nutt. All rights reserved. + * Copyright (C) 2007, 2009, 2011 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -37,14 +37,20 @@ * Included Files ************************************************************************/ +#include + #include #include #include #include #include + #include + #include "os_internal.h" +#ifdef CONFIG_SCHED_ATEXT + /************************************************************************ * Definitions ************************************************************************/ @@ -83,7 +89,7 @@ * func * * Return Value: - * zero on success. + * Zero on success. Non-zero on failure. * ************************************************************************/ @@ -92,11 +98,19 @@ int atexit(void (*func)(void)) _TCB *tcb = (_TCB*)g_readytorun.head; int ret = ERROR; - if ((func) && (!tcb->exitfunc)) + /* The following must be atomic */ + + sched_lock(); + if (func && !tcb->exitfunc) { tcb->exitfunc = func; ret = OK; } + + sched_unlock(); return ret; } +#endif /* CONFIG_SCHED_ATEXT */ + + diff --git a/nuttx/sched/exit.c b/nuttx/sched/exit.c index b1f743d97..2f287009b 100644 --- a/nuttx/sched/exit.c +++ b/nuttx/sched/exit.c @@ -130,11 +130,13 @@ void exit(int status) /* If an exit function was registered, call it now. */ - if (tcb->exitfunc) { - - (*tcb->exitfunc)(); +#ifdef CONFIG_SCHED_ATEXT + if (tcb->exitfunc) + { + (*tcb->exitfunc)(); + } +#endif - } /* end if */ /* Then "really" exit */ _exit(status); -- cgit v1.2.3