sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reduce debug output; calibrate DM320 timer

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@372 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2007-11-06 16:17:50 +00:00
parent 44778c69bd
commit ddeb703501
19 changed files with 414 additions and 441 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
TODO
View File

@ -44,7 +44,22 @@ o File system
- Add chmod(), truncate(). - Add chmod(), truncate().
- FAT32: long file names - FAT32: long file names
o Console Output o Network
- Did not implement send() and sendto() timeouts. Option is setable via setsockopt,
but is not implemented.
- netutils/webserver netutils/telnetd (and maybe others) are seriously broken.
- Should implement SOCK_RAW
- Performance Improvements (uIP is not very fast):
Add simple buffer management. CONFIG_NET_BUFFERS
(1) On write, queue buffer for output get a new buffer for the socket (waiting if
nececcesary
(2) Copy buffer structure into uip_driver_structure when driver requests write
data
Add a txail callback into driver to eliminate send delays. Since we want to
support multiple network devices, this means we will have to add some infrastructure
to map to device.
o Documentation o Documentation
- Document fs/ & driver/ logic - Document fs/ & driver/ logic
@ -61,6 +76,9 @@ o Applications & Tests
o C5471 o C5471
o DM320 o DM320
- It seems that when a lot of debug statements are added, the system no
longer boots. There could be some issue with the bootloader or with
the programming of the SDRAM MMU regions.
o LPC214x o LPC214x
- Finish bringup - Finish bringup

86
arch/arm/src/common/up_initialize.c
View File

@ -1,4 +1,4 @@
/************************************************************ /****************************************************************************
* common/up_initialize.c * common/up_initialize.c
* *
* Copyright (C) 2007 Gregory Nutt. All rights reserved. * Copyright (C) 2007 Gregory Nutt. All rights reserved.
@ -31,11 +31,11 @@
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
* *
************************************************************/ ****************************************************************************/
/************************************************************ /****************************************************************************
* Included Files * Included Files
************************************************************/ ****************************************************************************/
#include <nuttx/config.h> #include <nuttx/config.h>
#include <sys/types.h> #include <sys/types.h>
@ -45,37 +45,67 @@
#include "up_arch.h" #include "up_arch.h"
#include "up_internal.h" #include "up_internal.h"
/************************************************************ /****************************************************************************
* Definitions
****************************************************************************/
/* Define to enable timing loop calibration */
#undef CONFIG_ARM_CALIBRATION
/****************************************************************************
* Private Types * Private Types
************************************************************/ ****************************************************************************/
/************************************************************ /****************************************************************************
* Private Function Prototypes * Private Functions
************************************************************/ ****************************************************************************/
/************************************************************ /****************************************************************************
* Global Functions * Name: up_calibratedelay
************************************************************/ *
* Description:
* Delay loops are provided for short timing loops. This function, if
* enabled, will just wait for 100 seconds. Using a stopwatch, you can
* can then determine if the timing loops are properly calibrated.
*
****************************************************************************/
/************************************************************ #if defined(CONFIG_ARM_CALIBRATION) & defined(CONFIG_DEBUG)
static void up_calibratedelay(void)
{
int i;
lldbg("Beginning 100s delay\n");
for (i = 0; i < 100; i++)
{
up_mdelay(1000);
}
lldbg("End 100s delay\n");
}
#else
# define up_calibratedelay()
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: up_initialize * Name: up_initialize
* *
* Description: * Description:
* up_initialize will be called once during OS * up_initialize will be called once during OS initialization after the
* initialization after the basic OS services have been * basic OS services have been initialized. The architecture specific
* initialized. The architecture specific details of * details of initializing the OS will be handled here. Such things as
* initializing the OS will be handled here. Such things as * setting up interrupt service routines, starting the clock, and
* setting up interrupt service routines, starting the * registering device drivers are some of the things that are different
* clock, and registering device drivers are some of the * for each processor and hardware platform.
* things that are different for each processor and hardware
* platform.
* *
* up_initialize is called after the OS initialized but * up_initialize is called after the OS initialized but before the user
* before the init process has been started and before the * initialization logic has been started and before the libraries have
* libraries have been initialized. OS services and driver * been initialized. OS services and driver services are available.
* services are available.
* *
************************************************************/ ****************************************************************************/
void up_initialize(void) void up_initialize(void)
{ {
@ -83,6 +113,10 @@ void up_initialize(void)
current_regs = NULL; current_regs = NULL;
/* Calibrate the timing loop */
up_calibratedelay();
/* Initialize the interrupt subsystem */ /* Initialize the interrupt subsystem */
up_irqinitialize(); up_irqinitialize();

2
configs/ntosd-dm320/Make.defs
View File

@ -70,6 +70,6 @@ endif
HOSTCC = gcc HOSTCC = gcc
HOSTINCLUDES = -I. HOSTINCLUDES = -I.
HOSTCFLAGS = -Wall -wstrict-prototypes -Wshadow -g -pipe HOSTCFLAGS = -Wall -Wstrict-prototypes -Wshadow -g -pipe
HOSTLDFLAGS = HOSTLDFLAGS =

2
configs/ntosd-dm320/defconfig
View File

@ -58,7 +58,7 @@ CONFIG_ARCH_CHIP=dm320
CONFIG_ARCH_CHIP_DM320=y CONFIG_ARCH_CHIP_DM320=y
CONFIG_ARCH_BOARD=ntosd-dm320 CONFIG_ARCH_BOARD=ntosd-dm320
CONFIG_ARCH_BOARD_NTOSD_DM320=y CONFIG_ARCH_BOARD_NTOSD_DM320=y
CONFIG_BOARD_LOOPSPERMSEC=1250 CONFIG_BOARD_LOOPSPERMSEC=16945
CONFIG_DRAM_SIZE=0x01000000 CONFIG_DRAM_SIZE=0x01000000
CONFIG_DRAM_START=0x01000000 CONFIG_DRAM_START=0x01000000
CONFIG_DRAM_VSTART=0x00000000 CONFIG_DRAM_VSTART=0x00000000

305
drivers/net/dm90x0.c
View File

@ -270,7 +270,7 @@
/* This is a helper pointer for accessing the contents of the Ethernet header */ /* This is a helper pointer for accessing the contents of the Ethernet header */
#define BUF ((struct uip_eth_hdr *)dm9x->dev.d_buf) #define BUF ((struct uip_eth_hdr *)dm9x->dm_dev.d_buf)
/**************************************************************************** /****************************************************************************
* Private Types * Private Types
@ -278,12 +278,12 @@
union rx_desc_u union rx_desc_u
{ {
uint8 buf[4]; uint8 rx_buf[4];
struct struct
{ {
uint8 rxbyte; uint8 rx_byte;
uint8 status; uint8 rx_status;
uint16 length; uint16 rx_len;
} desc; } desc;
}; };
@ -293,35 +293,35 @@ union rx_desc_u
struct dm9x_driver_s struct dm9x_driver_s
{ {
boolean b100M; /* TRUE:speed == 100M; FALSE:speed == 10M */ boolean dm_b100M; /* TRUE:speed == 100M; FALSE:speed == 10M */
WDOG_ID txpoll; /* TX poll timer */ WDOG_ID dm_txpoll; /* TX poll timer */
WDOG_ID txtimeout; /* TX timeout timer */ WDOG_ID dm_txtimeout; /* TX timeout timer */
uint8 ntxpending; /* Count of packets pending transmission */ uint8 dm_ntxpending; /* Count of packets pending transmission */
uint8 ncrxpackets; /* Number of continuous rx packets */ uint8 ncrxpackets; /* Number of continuous rx packets */
/* Mode-dependent function to move data in 8/16/32 I/O modes */ /* Mode-dependent function to move data in 8/16/32 I/O modes */
void (*read)(uint8 *ptr, int len); void (*dm_read)(uint8 *ptr, int len);
void (*write)(const uint8 *ptr, int len); void (*dm_write)(const uint8 *ptr, int len);
void (*discard)(int len); void (*dm_discard)(int len);
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
uint32 ntxpackets; /* Count of packets sent */ uint32 dm_ntxpackets; /* Count of packets sent */
uint32 ntxbytes; /* Count of bytes sent */ uint32 dm_ntxbytes; /* Count of bytes sent */
uint32 ntxerrors; /* Count of TX errors */ uint32 dm_ntxerrors; /* Count of TX errors */
uint32 nrxpackets; /* Count of packets received */ uint32 dm_nrxpackets; /* Count of packets received */
uint32 nrxbytes; /* Count of bytes received */ uint32 dm_nrxbytes; /* Count of bytes received */
uint32 nrxfifoerrors; /* Count of RX FIFO overflow errors */ uint32 dm_nrxfifoerrors; /* Count of RX FIFO overflow errors */
uint32 nrxcrcerrors; /* Count of RX CRC errors */ uint32 dm_nrxcrcerrors; /* Count of RX CRC errors */
uint32 nrxlengtherrors; /* Count of RX length errors */ uint32 dm_nrxlengtherrors; /* Count of RX length errors */
uint32 nphyserrors; /* Count of physical layer errors */ uint32 dm_nphyserrors; /* Count of physical layer errors */
uint32 nresets; /* Counts number of resets */ uint32 dm_nresets; /* Counts number of resets */
uint32 ntxtimeouts; /* Counts resets caused by TX timeouts */ uint32 dm_ntxtimeouts; /* Counts resets caused by TX timeouts */
#endif #endif
/* This holds the information visible to uIP/NuttX */ /* This holds the information visible to uIP/NuttX */
struct uip_driver_s dev; struct uip_driver_s dm_dev;
}; };
/**************************************************************************** /****************************************************************************
@ -354,7 +354,7 @@ static void write32(const uint8 *ptr, int len);
static uint16 dm9x_phyread(struct dm9x_driver_s *dm9x, int reg); static uint16 dm9x_phyread(struct dm9x_driver_s *dm9x, int reg);
static void dm9x_phywrite(struct dm9x_driver_s *dm9x, int reg, uint16 value); static void dm9x_phywrite(struct dm9x_driver_s *dm9x, int reg, uint16 value);
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
static void dm9x_resetstatistics(struct dm9x_driver_s *dm9x); static void dm9x_resetstatistics(struct dm9x_driver_s *dm9x);
#else #else
# define dm9x_resetstatistics(dm9x) # define dm9x_resetstatistics(dm9x)
@ -665,20 +665,20 @@ static void dm9x_phywrite(struct dm9x_driver_s *dm9x, int reg, uint16 value)
* *
****************************************************************************/ ****************************************************************************/
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
static void dm9x_resetstatistics(struct dm9x_driver_s *dm9x) static void dm9x_resetstatistics(struct dm9x_driver_s *dm9x)
{ {
dm9x->ntxpackets = 0; /* Count of packets sent */ dm9x->dm_ntxpackets = 0; /* Count of packets sent */
dm9x->ntxbytes = 0; /* Count of bytes sent */ dm9x->dm_ntxbytes = 0; /* Count of bytes sent */
dm9x->ntxerrors = 0; /* Count of TX errors */ dm9x->dm_ntxerrors = 0; /* Count of TX errors */
dm9x->nrxpackets = 0; /* Count of packets received */ dm9x->dm_nrxpackets = 0; /* Count of packets received */
dm9x->nrxbytes = 0; /* Count of bytes received */ dm9x->dm_nrxbytes = 0; /* Count of bytes received */
dm9x->nrxfifoerrors = 0; /* Count of RX FIFO overflow errors */ dm9x->dm_nrxfifoerrors = 0; /* Count of RX FIFO overflow errors */
dm9x->nrxcrcerrors = 0; /* Count of RX CRC errors */ dm9x->dm_nrxcrcerrors = 0; /* Count of RX CRC errors */
dm9x->nrxlengtherrors = 0; /* Count of RX length errors */ dm9x->dm_nrxlengtherrors = 0; /* Count of RX length errors */
dm9x->nphyserrors = 0; /* Count of physical layer errors */ dm9x->dm_nphyserrors = 0; /* Count of physical layer errors */
dm9x->nresets = 0; /* Counts number of resets */ dm9x->dm_nresets = 0; /* Counts number of resets */
dm9x->ntxtimeouts = 0; /* Counts resets caused by TX timeouts */ dm9x->dm_ntxtimeouts = 0; /* Counts resets caused by TX timeouts */
} }
#endif #endif
@ -701,17 +701,17 @@ static void dm9x_resetstatistics(struct dm9x_driver_s *dm9x)
#if defined(CONFIG_DM9X_STATS) && defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS) && defined(CONFIG_DEBUG)
static void dm9x_dumpstatistics(struct dm9x_driver_s *dm9x) static void dm9x_dumpstatistics(struct dm9x_driver_s *dm9x)
{ {
dbg("TX packets: %d\n", dm9x->ntxpackets); dbg("TX packets: %d\n", dm9x->dm_ntxpackets);
dbg(" bytes: %d\n", dm9x->ntxbytes); dbg(" bytes: %d\n", dm9x->dm_ntxbytes);
dbg(" errors: %d\n", dm9x->ntxerrors); dbg(" errors: %d\n", dm9x->dm_ntxerrors);
dbg("RX packets: %d\n", dm9x->nrxpackets); dbg("RX packets: %d\n", dm9x->dm_nrxpackets);
dbg(" bytes: %d\n", dm9x->nrxbytes); dbg(" bytes: %d\n", dm9x->dm_nrxbytes);
dbg(" FIFO overflows: %d\n", dm9x->nrxfifoerrors); dbg(" FIFO overflows: %d\n", dm9x->dm_nrxfifoerrors);
dbg(" CRC errors: %d\n", dm9x->nrxcrcerrors); dbg(" CRC errors: %d\n", dm9x->dm_nrxcrcerrors);
dbg(" length errors: %d\n", dm9x->nrxlengtherrors); dbg(" length errors: %d\n", dm9x->dm_nrxlengtherrors);
dbg("Physical layer errors: %d\n", dm9x->nphyserrors); dbg("Physical layer errors: %d\n", dm9x->dm_nphyserrors);
dbg("Resets: %d\n", dm9x->nresets); dbg("Resets: %d\n", dm9x->dm_nresets);
dbg("TX timeout resets: %d\n", dm9x->ntxtimeouts); dbg("TX timeout resets: %d\n", dm9x->dm_ntxtimeouts);
} }
#endif #endif
@ -764,10 +764,10 @@ static int dm9x_transmit(struct dm9x_driver_s *dm9x)
{ {
/* Increment count of packets transmitted */ /* Increment count of packets transmitted */
dm9x->ntxpending++; dm9x->dm_ntxpending++;
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
dm9x->ntxpackets++; dm9x->dm_ntxpackets++;
dm9x->ntxbytes += dm9x->dev.d_len; dm9x->dm_ntxbytes += dm9x->dm_dev.d_len;
#endif #endif
/* Disable all DM90x0 interrupts */ /* Disable all DM90x0 interrupts */
@ -776,13 +776,13 @@ static int dm9x_transmit(struct dm9x_driver_s *dm9x)
/* Set the TX length */ /* Set the TX length */
putreg(DM9X_TXPLL, (dm9x->dev.d_len & 0xff)); putreg(DM9X_TXPLL, (dm9x->dm_dev.d_len & 0xff));
putreg(DM9X_TXPLH, (dm9x->dev.d_len >> 8) & 0xff); putreg(DM9X_TXPLH, (dm9x->dm_dev.d_len >> 8) & 0xff);
/* Move the data to be sent into TX SRAM */ /* Move the data to be sent into TX SRAM */
DM9X_INDEX = DM9X_MWCMD; DM9X_INDEX = DM9X_MWCMD;
dm9x->write(dm9x->dev.d_buf, dm9x->dev.d_len); dm9x->dm_write(dm9x->dm_dev.d_buf, dm9x->dm_dev.d_len);
#if !defined(CONFIG_DM9X_ETRANS) #if !defined(CONFIG_DM9X_ETRANS)
/* Issue TX polling command */ /* Issue TX polling command */
@ -800,7 +800,7 @@ static int dm9x_transmit(struct dm9x_driver_s *dm9x)
/* Setup the TX timeout watchdog (perhaps restarting the timer) */ /* Setup the TX timeout watchdog (perhaps restarting the timer) */
(void)wd_start(dm9x->txtimeout, DM6X_TXTIMEOUT, dm9x_txtimeout, 1, (uint32)dm9x); (void)wd_start(dm9x->dm_txtimeout, DM6X_TXTIMEOUT, dm9x_txtimeout, 1, (uint32)dm9x);
return OK; return OK;
} }
@ -833,16 +833,16 @@ static int dm9x_uiptxpoll(struct uip_driver_s *dev)
* the field d_len is set to a value > 0. * the field d_len is set to a value > 0.
*/ */
if (dm9x->dev.d_len > 0) if (dm9x->dm_dev.d_len > 0)
{ {
uip_arp_out(&dm9x->dev); uip_arp_out(&dm9x->dm_dev);
dm9x_transmit(dm9x); dm9x_transmit(dm9x);
/* Check if there is room in the DM90x0 to hold another packet. In 100M mode, /* Check if there is room in the DM90x0 to hold another packet. In 100M mode,
* that can be 2 packets, otherwise it is a single packet. * that can be 2 packets, otherwise it is a single packet.
*/ */
if (dm9x->ntxpending > 1 || !dm9x->b100M) if (dm9x->dm_ntxpending > 1 || !dm9x->dm_b100M)
{ {
/* Returning a non-zero value will terminate the poll operation */ /* Returning a non-zero value will terminate the poll operation */
@ -881,7 +881,7 @@ static void dm9x_receive(struct dm9x_driver_s *dm9x)
uint8 mdral; uint8 mdral;
uint8 rxbyte; uint8 rxbyte;
dbg("Packet received\n"); vdbg("Packet received\n");
do do
{ {
@ -907,62 +907,64 @@ static void dm9x_receive(struct dm9x_driver_s *dm9x)
/* Read packet status & length */ /* Read packet status & length */
dm9x->read((uint8*)&rx, 4); dm9x->dm_read((uint8*)&rx, 4);
/* Check if any errors were reported by the hardware */ /* Check if any errors were reported by the hardware */
if (rx.desc.status & 0xbf) if (rx.desc.rx_status & 0xbf)
{ {
/* Bad RX packet... update statistics */ /* Bad RX packet... update statistics */
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
if (rx.desc.status & 0x01) if (rx.desc.rx_status & 0x01)
{ {
dm9x->nrxfifoerrors++; dm9x->dm_nrxfifoerrors++;
dbg("RX FIFO error: %d\n", dm9x->nrxfifoerrors); dbg("RX FIFO error: %d\n", dm9x->dm_nrxfifoerrors);
} }
if (rx.desc.status & 0x02) if (rx.desc.rx_status & 0x02)
{ {
dm9x->nrxcrcerrors++; dm9x->dm_nrxcrcerrors++;
dbg("RX CRC error: %d\n", dm9x->nrxcrcerrors); dbg("RX CRC error: %d\n", dm9x->dm_nrxcrcerrors);
} }
if (rx.desc.status & 0x80) if (rx.desc.rx_status & 0x80)
{ {
dm9x->nrxlengtherrors++; dm9x->dm_nrxlengtherrors++;
dbg("RX length error: %d\n", dm9x->nrxlengtherrors); dbg("RX length error: %d\n", dm9x->dm_nrxlengtherrors);
} }
if (rx.desc.status & 0x08) if (rx.desc.rx_status & 0x08)
{ {
dm9x->nphyserrors++; dm9x->dm_nphyserrors++;
dbg("Physical Layer error: %d\n", dm9x->nphyserrors); dbg("Physical Layer error: %d\n", dm9x->dm_nphyserrors);
} }
#else
dbg("Received packet with errors: %02x\n", rx.desc.rx_status);
#endif #endif
/* Drop this packet and continue to check the next packet */ /* Drop this packet and continue to check the next packet */
dm9x->discard(rx.desc.length); dm9x->dm_discard(rx.desc.rx_len);
} }
/* Also check if the packet is a valid size for the uIP configuration */ /* Also check if the packet is a valid size for the uIP configuration */
else if (rx.desc.length < UIP_LLH_LEN || rx.desc.length > (UIP_BUFSIZE + 2)) else if (rx.desc.rx_len < UIP_LLH_LEN || rx.desc.rx_len > (UIP_BUFSIZE + 2))
{ {
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
dm9x->nrxlengtherrors++; dm9x->dm_nrxlengtherrors++;
dbg("RX length error: %d\n", dm9x->nrxlengtherrors); dbg("RX length error: %d\n", dm9x->dm_nrxlengtherrors);
#endif #endif
/* Drop this packet and continue to check the next packet */ /* Drop this packet and continue to check the next packet */
dm9x->discard(rx.desc.length); dm9x->dm_discard(rx.desc.rx_len);
} }
else else
{ {
/* Good packet... Copy the packet data out of SRAM and pass it one to uIP */ /* Good packet... Copy the packet data out of SRAM and pass it one to uIP */
dm9x->dev.d_len = rx.desc.length; dm9x->dm_dev.d_len = rx.desc.rx_len;
dm9x->read(dm9x->dev.d_buf, rx.desc.length); dm9x->dm_read(dm9x->dm_dev.d_buf, rx.desc.rx_len);
/* We only accept IP packets of the configured type and ARP packets */ /* We only accept IP packets of the configured type and ARP packets */
@ -973,43 +975,43 @@ static void dm9x_receive(struct dm9x_driver_s *dm9x)
#endif #endif
{ {
uip_arp_ipin(); uip_arp_ipin();
uip_input(&dm9x->dev); uip_input(&dm9x->dm_dev);
/* If the above function invocation resulted in data that /* If the above function invocation resulted in data that
* should be sent out on the network, the global variable * should be sent out on the network, the global variable
* d_len is set to a value > 0. * d_len is set to a value > 0.
*/ */
if (dm9x->dev.d_len > 0) if (dm9x->dm_dev.d_len > 0)
{ {
uip_arp_out(&dm9x->dev); uip_arp_out(&dm9x->dm_dev);
dm9x_transmit(dm9x); dm9x_transmit(dm9x);
} }
} }
else if (BUF->type == htons(UIP_ETHTYPE_ARP)) else if (BUF->type == htons(UIP_ETHTYPE_ARP))
{ {
uip_arp_arpin(&dm9x->dev); uip_arp_arpin(&dm9x->dm_dev);
/* If the above function invocation resulted in data that /* If the above function invocation resulted in data that
* should be sent out on the network, the global variable * should be sent out on the network, the global variable
* d_len is set to a value > 0. * d_len is set to a value > 0.
*/ */
if (dm9x->dev.d_len > 0) if (dm9x->dm_dev.d_len > 0)
{ {
dm9x_transmit(dm9x); dm9x_transmit(dm9x);
} }
} }
} }
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
dm9x->nrxpackets++; dm9x->dm_nrxpackets++;
dm9x->nrxbytes += rx.desc.length; dm9x->dm_nrxbytes += rx.desc.rx_len;
#endif #endif
dm9x->ncrxpackets++; dm9x->ncrxpackets++;
} }
while ((rxbyte & 0x01) == DM9X_PKTRDY && dm9x->ncrxpackets < DM9X_CRXTHRES); while ((rxbyte & 0x01) == DM9X_PKTRDY && dm9x->ncrxpackets < DM9X_CRXTHRES);
dbg("All RX packets processed\n"); vdbg("All RX packets processed\n");
} }
/**************************************************************************** /****************************************************************************
@ -1032,7 +1034,7 @@ static void dm9x_txdone(struct dm9x_driver_s *dm9x)
{ {
int nsr; int nsr;
dbg("TX done\n"); vdbg("TX done\n");
/* Another packet has completed transmission. Decrement the count of /* Another packet has completed transmission. Decrement the count of
* of pending TX transmissions. * of pending TX transmissions.
@ -1041,38 +1043,38 @@ static void dm9x_txdone(struct dm9x_driver_s *dm9x)
nsr = getreg(DM9X_NETS); nsr = getreg(DM9X_NETS);
if (nsr & DM9X_NETS_TX1END) if (nsr & DM9X_NETS_TX1END)
{ {
if (dm9x->ntxpending) if (dm9x->dm_ntxpending)
{ {
dm9x->ntxpending--; dm9x->dm_ntxpending--;
} }
else else
{ {
dbg("ntxpending ERROR on TX1END\n"); dbg("Bad TX count (TX1END)\n");
} }
} }
if (nsr & DM9X_NETS_TX2END) if (nsr & DM9X_NETS_TX2END)
{ {
if (dm9x->ntxpending) if (dm9x->dm_ntxpending)
{ {
dm9x->ntxpending--; dm9x->dm_ntxpending--;
} }
else else
{ {
dbg("ntxpending ERROR on TX2END\n"); dbg("Bad TX count (TX2END)\n");
} }
} }
/* Cancel the TX timeout */ /* Cancel the TX timeout */
if (dm9x->ntxpending == 0) if (dm9x->dm_ntxpending == 0)
{ {
wd_cancel(dm9x->txtimeout); wd_cancel(dm9x->dm_txtimeout);
} }
/* Then poll uIP for new XMIT data */ /* Then poll uIP for new XMIT data */
(void)uip_poll(&dm9x->dev, dm9x_uiptxpoll, UIP_POLL); (void)uip_poll(&dm9x->dm_dev, dm9x_uiptxpoll, UIP_POLL);
} }
/**************************************************************************** /****************************************************************************
@ -1111,7 +1113,7 @@ static int dm9x_interrupt(int irq, FAR void *context)
isr = getreg(DM9X_ISR); isr = getreg(DM9X_ISR);
putreg(DM9X_ISR, isr); putreg(DM9X_ISR, isr);
vdbg("Interrupt: ISR=%02x\n", isr); vdbg("Interrupt status: %02x\n", isr);
/* Check for link status change */ /* Check for link status change */
@ -1135,17 +1137,17 @@ static int dm9x_interrupt(int irq, FAR void *context)
if (dm9x_phyread(dm9x, 0) & 0x2000) if (dm9x_phyread(dm9x, 0) & 0x2000)
{ {
dm9x->b100M = TRUE; dm9x->dm_b100M = TRUE;
} }
else else
{ {
dm9x->b100M = FALSE; dm9x->dm_b100M = FALSE;
} }
break; break;
} }
up_mdelay(1); up_mdelay(1);
} }
dbg("delay: %d mS speed: %s\n", i, dm9x->b100M ? "100M" : "10M"); dbg("delay: %dmS speed: %s\n", i, dm9x->dm_b100M ? "100M" : "10M");
} }
/* Check if we received an incoming packet */ /* Check if we received an incoming packet */
@ -1211,13 +1213,13 @@ static void dm9x_txtimeout(int argc, uint32 arg, ...)
/* Increment statistics and dump debug info */ /* Increment statistics and dump debug info */
#if defined(CONFIG_DM9X_STATS) || defined(CONFIG_DEBUG) #if defined(CONFIG_DM9X_STATS)
dm9x->ntxtimeouts++; dm9x->dm_ntxtimeouts++;
dm9x->ntxerrors++; dm9x->dm_ntxerrors++;
#endif #endif
dbg(" TX packet count: %d\n", dm9x->ntxpending); dbg(" TX packet count: %d\n", dm9x->dm_ntxpending);
dbg(" TX timeouts: %d\n", dm9x->ntxtimeouts); dbg(" TX timeouts: %d\n", dm9x->dm_ntxtimeouts);
dbg(" TX read pointer address: 0x%02x:%02x\n", dbg(" TX read pointer address: 0x%02x:%02x\n",
getreg(DM9X_TRPAH), getreg(DM9X_TRPAL)); getreg(DM9X_TRPAH), getreg(DM9X_TRPAL));
dbg(" Memory data write address: 0x%02x:%02x (DM9010)\n", dbg(" Memory data write address: 0x%02x:%02x (DM9010)\n",
@ -1229,7 +1231,7 @@ static void dm9x_txtimeout(int argc, uint32 arg, ...)
/* Then poll uIP for new XMIT data */ /* Then poll uIP for new XMIT data */
(void)uip_poll(&dm9x->dev, dm9x_uiptxpoll, UIP_POLL); (void)uip_poll(&dm9x->dm_dev, dm9x_uiptxpoll, UIP_POLL);
} }
/**************************************************************************** /****************************************************************************
@ -1269,16 +1271,16 @@ static void dm9x_polltimer(int argc, uint32 arg, ...)
* that can be 2 packets, otherwise it is a single packet. * that can be 2 packets, otherwise it is a single packet.
*/ */
if (dm9x->ntxpending < 1 || (dm9x->b100M && dm9x->ntxpending < 2)) if (dm9x->dm_ntxpending < 1 || (dm9x->dm_b100M && dm9x->dm_ntxpending < 2))
{ {
/* If so, poll uIP for new XMIT data */ /* If so, poll uIP for new XMIT data */
(void)uip_poll(&dm9x->dev, dm9x_uiptxpoll, UIP_TIMER); (void)uip_poll(&dm9x->dm_dev, dm9x_uiptxpoll, UIP_TIMER);
} }
/* Setup the watchdog poll timer again */ /* Setup the watchdog poll timer again */
(void)wd_start(dm9x->txpoll, DM6X_WDDELAY, dm9x_polltimer, 1, arg); (void)wd_start(dm9x->dm_txpoll, DM6X_WDDELAY, dm9x_polltimer, 1, arg);
} }
/**************************************************************************** /****************************************************************************
@ -1356,7 +1358,7 @@ static int dm9x_ifup(struct uip_driver_s *dev)
/* Check link state and media speed (waiting up to 3s for link OK) */ /* Check link state and media speed (waiting up to 3s for link OK) */
dm9x->b100M = FALSE; dm9x->dm_b100M = FALSE;
for (i = 0; i < 3000; i++) for (i = 0; i < 3000; i++)
{ {
netstatus = getreg(DM9X_NETS); netstatus = getreg(DM9X_NETS);
@ -1368,7 +1370,7 @@ static int dm9x_ifup(struct uip_driver_s *dev)
netstatus = getreg(DM9X_NETS); netstatus = getreg(DM9X_NETS);
if ((netstatus & DM9X_NETS_SPEED) == 0) if ((netstatus & DM9X_NETS_SPEED) == 0)
{ {
dm9x->b100M = TRUE; dm9x->dm_b100M = TRUE;
} }
break; break;
} }
@ -1376,11 +1378,11 @@ static int dm9x_ifup(struct uip_driver_s *dev)
up_mdelay(1); up_mdelay(1);
} }
dbg("i=%d mS speed=%s\n", i, dm9x->b100M ? "100M" : "10M"); dbg("delay: %dmS speed: %s\n", i, dm9x->dm_b100M ? "100M" : "10M");
/* Set and activate a timer process */ /* Set and activate a timer process */
(void)wd_start(dm9x->txpoll, DM6X_WDDELAY, dm9x_polltimer, 1, (uint32)dm9x); (void)wd_start(dm9x->dm_txpoll, DM6X_WDDELAY, dm9x_polltimer, 1, (uint32)dm9x);
/* Enable the DM9X interrupt */ /* Enable the DM9X interrupt */
@ -1418,12 +1420,12 @@ static int dm9x_ifdown(struct uip_driver_s *dev)
/* Cancel the TX poll timer and TX timeout timers */ /* Cancel the TX poll timer and TX timeout timers */
wd_cancel(dm9x->txpoll); wd_cancel(dm9x->dm_txpoll);
wd_cancel(dm9x->txtimeout); wd_cancel(dm9x->dm_txtimeout);
/* Reset the device */ /* Reset the device */
dm9x_phywrite(dm9x, 0x00, 0x8000); /* PHY RESET */ dm9x_phywrite(dm9x, 0x00, 0x8000); /* PHY reset */
putreg(DM9X_GPD, 0x01); /* Power-down PHY (GEPIO0=1) */ putreg(DM9X_GPD, 0x01); /* Power-down PHY (GEPIO0=1) */
putreg(DM9X_IMR, DM9X_IMRDISABLE); /* Disable all interrupts */ putreg(DM9X_IMR, DM9X_IMRDISABLE); /* Disable all interrupts */
putreg(DM9X_RXC, 0x00); /* Disable RX */ putreg(DM9X_RXC, 0x00); /* Disable RX */
@ -1461,7 +1463,7 @@ static void dm9x_bringup(struct dm9x_driver_s *dm9x)
putreg(DM9X_GPD, 0x01); /* Power-down the PHY (GEPIO0=1) */ putreg(DM9X_GPD, 0x01); /* Power-down the PHY (GEPIO0=1) */
up_udelay(500); up_udelay(500);
putreg(DM9X_GPD, 0x00); /* Preactivate PHY (GPIO0=0 */ putreg(DM9X_GPD, 0x00); /* Preactivate PHY (GPIO0=0 */
up_udelay(20); /* Wait 2ms for PHY power-on ready */ up_udelay(20); /* Wait 20us for PHY power-on ready */
/* Do a software reset and wait 20us (twice). The reset autoclears /* Do a software reset and wait 20us (twice). The reset autoclears
* in 10us; 20us guarantees completion of the reset * in 10us; 20us guarantees completion of the reset
@ -1477,35 +1479,35 @@ static void dm9x_bringup(struct dm9x_driver_s *dm9x)
switch (getreg(DM9X_ISR) & DM9X_ISR_IOMODEM) switch (getreg(DM9X_ISR) & DM9X_ISR_IOMODEM)
{ {
case DM9X_ISR_IOMODE8: case DM9X_ISR_IOMODE8:
dm9x->read = read8; dm9x->dm_read = read8;
dm9x->write = write8; dm9x->dm_write = write8;
dm9x->discard = discard8; dm9x->dm_discard = discard8;
break; break;
case DM9X_ISR_IOMODE16: case DM9X_ISR_IOMODE16:
dm9x->read = read16; dm9x->dm_read = read16;
dm9x->write = write16; dm9x->dm_write = write16;
dm9x->discard = discard16; dm9x->dm_discard = discard16;
break; break;
case DM9X_ISR_IOMODE32: case DM9X_ISR_IOMODE32:
dm9x->read = read32; dm9x->dm_read = read32;
dm9x->write = write32; dm9x->dm_write = write32;
dm9x->discard = discard32; dm9x->dm_discard = discard32;
break; break;
default: default:
break; break;
} }
/* Set PHY operating mode */ /* Program PHY operating mode */
dm9x_phymode(dm9x); dm9x_phymode(dm9x);
/* Program operating register */ /* Program operating mode */
putreg(DM9X_NETC, 0x00); /* Network control */ putreg(DM9X_NETC, 0x00); /* Network control */
putreg(DM9X_TXC, 0x00); /* TX Polling clear */ putreg(DM9X_TXC, 0x00); /* Clear TX Polling */
putreg(DM9X_BPTHRES, 0x3f); /* Less 3kb, 600us */ putreg(DM9X_BPTHRES, 0x3f); /* Less 3kb, 600us */
putreg(DM9X_SMODEC, 0x00); /* Special mode */ putreg(DM9X_SMODEC, 0x00); /* Special mode */
putreg(DM9X_NETS, (DM9X_NETS_WAKEST|DM9X_NETS_TX1END|DM9X_NETS_TX2END)); /* Clear TX status */ putreg(DM9X_NETS, (DM9X_NETS_WAKEST|DM9X_NETS_TX1END|DM9X_NETS_TX2END)); /* Clear TX status */
@ -1523,7 +1525,7 @@ static void dm9x_bringup(struct dm9x_driver_s *dm9x)
/* Initialize statistics */ /* Initialize statistics */
dm9x->ncrxpackets = 0; /* Number of continuous RX packets */ dm9x->ncrxpackets = 0; /* Number of continuous RX packets */
dm9x->ntxpending = 0; /* Number of pending TX packets */ dm9x->dm_ntxpending = 0; /* Number of pending TX packets */
dm9x_resetstatistics(dm9x); dm9x_resetstatistics(dm9x);
/* Activate DM9000A/DM9010 */ /* Activate DM9000A/DM9010 */
@ -1556,26 +1558,26 @@ static void dm9x_reset(struct dm9x_driver_s *dm9x)
/* Cancel the TX poll timer and TX timeout timers */ /* Cancel the TX poll timer and TX timeout timers */
wd_cancel(dm9x->txpoll); wd_cancel(dm9x->dm_txpoll);
wd_cancel(dm9x->txtimeout); wd_cancel(dm9x->dm_txtimeout);
/* Save previous register address */ /* Save previous register address */
save = (uint8)DM9X_INDEX; save = (uint8)DM9X_INDEX;
dm9x->nresets++; dm9x->dm_nresets++;
dm9x_bringup(dm9x); dm9x_bringup(dm9x);
/* Wait up to 1 second for the link to be OK */ /* Wait up to 1 second for the link to be OK */
dm9x->b100M = FALSE; dm9x->dm_b100M = FALSE;
for (i = 0; i < 1000; i++) for (i = 0; i < 1000; i++)
{ {
if (dm9x_phyread(dm9x,0x1) & 0x4) /*Link OK*/ if (dm9x_phyread(dm9x,0x1) & 0x4)
{ {
if (dm9x_phyread(dm9x, 0) &0x2000) if (dm9x_phyread(dm9x, 0) &0x2000)
{ {
dm9x->b100M = TRUE; dm9x->dm_b100M = TRUE;
} }
break; break;
} }
@ -1627,7 +1629,7 @@ int dm9x_initialize(void)
if (vid != DM9X_DAVICOMVID || (pid != DM9X_DM9000PID && pid != DM9X_DM9010PID)) if (vid != DM9X_DAVICOMVID || (pid != DM9X_DM9000PID && pid != DM9X_DM9010PID))
{ {
dbg("DM90x0 vender/product ID not found at this base address\n"); lldbg("DM90x0 vender/product ID not found at this base address\n");
return -ENODEV; return -ENODEV;
} }
@ -1636,6 +1638,7 @@ int dm9x_initialize(void)
if (irq_attach(CONFIG_DM9X_IRQ, dm9x_interrupt)) if (irq_attach(CONFIG_DM9X_IRQ, dm9x_interrupt))
{ {
/* We could not attach the ISR to the ISR */ /* We could not attach the ISR to the ISR */
lldbg("irq_attach() failed\n"); lldbg("irq_attach() failed\n");
return -EAGAIN; return -EAGAIN;
} }
@ -1643,18 +1646,18 @@ int dm9x_initialize(void)
/* Initialize the driver structure */ /* Initialize the driver structure */
memset(g_dm9x, 0, CONFIG_DM9X_NINTERFACES*sizeof(struct dm9x_driver_s)); memset(g_dm9x, 0, CONFIG_DM9X_NINTERFACES*sizeof(struct dm9x_driver_s));
g_dm9x[0].dev.ifup = dm9x_ifup; /* I/F down callback */ g_dm9x[0].dm_dev.d_ifup = dm9x_ifup; /* I/F down callback */
g_dm9x[0].dev.ifdown = dm9x_ifdown; /* I/F up (new IP address) callback */ g_dm9x[0].dm_dev.d_ifdown = dm9x_ifdown; /* I/F up (new IP address) callback */
g_dm9x[0].dev.d_private = (void*)g_dm9x; /* Used to recover private state from dev */ g_dm9x[0].dm_dev.d_private = (void*)g_dm9x; /* Used to recover private state from dev */
/* Create a watchdog for timing polling for and timing of transmisstions */ /* Create a watchdog for timing polling for and timing of transmisstions */
g_dm9x[0].txpoll = wd_create(); /* Create periodic poll timer */ g_dm9x[0].dm_txpoll = wd_create(); /* Create periodic poll timer */
g_dm9x[0].txtimeout = wd_create(); /* Create TX timeout timer */ g_dm9x[0].dm_txtimeout = wd_create(); /* Create TX timeout timer */
/* Read the MAC address */ /* Read the MAC address */
mptr = g_dm9x[0].dev.d_mac.addr; mptr = g_dm9x[0].dm_dev.d_mac.addr;
for (i = 0, j = DM9X_PAB0; i < 6; i++, j++) for (i = 0, j = DM9X_PAB0; i < 6; i++, j++)
{ {
mptr[i] = getreg(j); mptr[i] = getreg(j);
@ -1665,7 +1668,7 @@ int dm9x_initialize(void)
/* Register the device with the OS so that socket IOCTLs can be performed */ /* Register the device with the OS so that socket IOCTLs can be performed */
(void)netdev_register(&g_dm9x[0].dev); (void)netdev_register(&g_dm9x[0].dm_dev);
return OK; return OK;
} }

30
examples/nettest/nettest-client.c
View File

@ -73,7 +73,7 @@ void send_client(void)
sockfd = socket(PF_INET, SOCK_STREAM, 0); sockfd = socket(PF_INET, SOCK_STREAM, 0);
if (sockfd < 0) if (sockfd < 0)
{ {
printf("client socket failure %d\n", errno); message("client socket failure %d\n", errno);
exit(1); exit(1);
} }
@ -87,13 +87,13 @@ void send_client(void)
myaddr.sin_addr.s_addr = HTONL(CONFIG_EXAMPLE_NETTEST_CLIENTIP); myaddr.sin_addr.s_addr = HTONL(CONFIG_EXAMPLE_NETTEST_CLIENTIP);
#endif #endif
printf("client: Connecting...\n"); message("client: Connecting...\n");
if (connect( sockfd, (struct sockaddr*)&myaddr, sizeof(struct sockaddr_in)) < 0) if (connect( sockfd, (struct sockaddr*)&myaddr, sizeof(struct sockaddr_in)) < 0)
{ {
printf("client: connect failure: %d\n", errno); message("client: connect failure: %d\n", errno);
exit(1); exit(1);
} }
printf("client: Connected\n"); message("client: Connected\n");
/* Initialize the buffer */ /* Initialize the buffer */
@ -115,13 +115,13 @@ void send_client(void)
nbytessent = send(sockfd, outbuf, 512, 0); nbytessent = send(sockfd, outbuf, 512, 0);
if (nbytessent < 0) if (nbytessent < 0)
{ {
printf("client: send failed: %d\n", errno); message("client: send failed: %d\n", errno);
close(sockfd); close(sockfd);
exit(-1); exit(-1);
} }
else if (nbytessent != 512) else if (nbytessent != 512)
{ {
printf("client: Bad send length=%d: %d\n", nbytessent); message("client: Bad send length=%d: %d\n", nbytessent);
close(sockfd); close(sockfd);
exit(-1); exit(-1);
} }
@ -129,42 +129,42 @@ void send_client(void)
#else #else
/* Then send and receive one message */ /* Then send and receive one message */
printf("client: Sending %d bytes\n", SENDSIZE); message("client: Sending %d bytes\n", SENDSIZE);
nbytessent = send(sockfd, outbuf, SENDSIZE, 0); nbytessent = send(sockfd, outbuf, SENDSIZE, 0);
printf("client: Sent %d bytes\n", nbytessent); message("client: Sent %d bytes\n", nbytessent);
if (nbytessent < 0) if (nbytessent < 0)
{ {
printf("client: send failed: %d\n", errno); message("client: send failed: %d\n", errno);
close(sockfd); close(sockfd);
exit(-1); exit(-1);
} }
else if (nbytessent != SENDSIZE) else if (nbytessent != SENDSIZE)
{ {
printf("client: Bad send length=%d: %d\n", nbytessent); message("client: Bad send length=%d: %d\n", nbytessent);
close(sockfd); close(sockfd);
exit(-1); exit(-1);
} }
printf("client: Receiving...\n"); message("client: Receiving...\n");
nbytesrecvd = recv(sockfd, inbuf, SENDSIZE, 0); nbytesrecvd = recv(sockfd, inbuf, SENDSIZE, 0);
printf("client: Received %d bytes\n", nbytesrecvd); message("client: Received %d bytes\n", nbytesrecvd);
if (nbytesrecvd < 0) if (nbytesrecvd < 0)
{ {
printf("client: recv failed: %d\n", errno); message("client: recv failed: %d\n", errno);
close(sockfd); close(sockfd);
exit(-1); exit(-1);
} }
else if (nbytesrecvd != SENDSIZE) else if (nbytesrecvd != SENDSIZE)
{ {
printf("client: Bad recv length=%d: %d\n", nbytessent); message("client: Bad recv length=%d: %d\n", nbytessent);
close(sockfd); close(sockfd);
exit(-1); exit(-1);
} }
else if (memcmp(inbuf, outbuf, SENDSIZE) != 0) else if (memcmp(inbuf, outbuf, SENDSIZE) != 0)
{ {
printf("client: Received buffer does not match sent buffer\n"); message("client: Received buffer does not match sent buffer\n");
close(sockfd); close(sockfd);
exit(-1); exit(-1);
} }

30
examples/nettest/nettest-server.c
View File

@ -73,7 +73,7 @@ void recv_server(void)
listensd = socket(PF_INET, SOCK_STREAM, 0); listensd = socket(PF_INET, SOCK_STREAM, 0);
if (listensd < 0) if (listensd < 0)
{ {
printf("server: socket failure: %d\n", errno); message("server: socket failure: %d\n", errno);
exit(1); exit(1);
} }
@ -82,7 +82,7 @@ void recv_server(void)
optval = 1; optval = 1;
if (setsockopt(listensd, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof(int)) < 0) if (setsockopt(listensd, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof(int)) < 0)
{ {
printf("server: setsockopt failure: %d\n", errno); message("server: setsockopt failure: %d\n", errno);
exit(1); exit(1);
} }
@ -94,7 +94,7 @@ void recv_server(void)
if (bind(listensd, (struct sockaddr*)&myaddr, sizeof(struct sockaddr_in)) < 0) if (bind(listensd, (struct sockaddr*)&myaddr, sizeof(struct sockaddr_in)) < 0)
{ {
printf("server: bind failure: %d\n", errno); message("server: bind failure: %d\n", errno);
exit(1); exit(1);
} }
@ -102,21 +102,21 @@ void recv_server(void)
if (listen(listensd, 5) < 0) if (listen(listensd, 5) < 0)
{ {
printf("server: listen failure %d\n", errno); message("server: listen failure %d\n", errno);
exit(1); exit(1);
} }
/* Accept only one connection */ /* Accept only one connection */
printf("server: Accepting connections on port %d\n", PORTNO); message("server: Accepting connections on port %d\n", PORTNO);
addrlen = sizeof(struct sockaddr_in); addrlen = sizeof(struct sockaddr_in);
acceptsd = accept(listensd, (struct sockaddr*)&myaddr, &addrlen); acceptsd = accept(listensd, (struct sockaddr*)&myaddr, &addrlen);
if (acceptsd < 0) if (acceptsd < 0)
{ {
printf("server: accept failure: %d\n", errno); message("server: accept failure: %d\n", errno);
exit(1); exit(1);
} }
printf("server: Connection accepted -- receiving\n"); message("server: Connection accepted -- receiving\n");
#ifdef CONFIG_NETTEST_PERFORMANCE #ifdef CONFIG_NETTEST_PERFORMANCE
/* Then receive data forever */ /* Then receive data forever */
@ -126,7 +126,7 @@ void recv_server(void)
nbytesread = recv(acceptsd, buffer, 1024, 0); nbytesread = recv(acceptsd, buffer, 1024, 0);
if (nbytesread <= 0) if (nbytesread <= 0)
{ {
printf("server: recv failed: %d\n", errno); message("server: recv failed: %d\n", errno);
close(listensd); close(listensd);
close(acceptsd); close(acceptsd);
exit(-1); exit(-1);
@ -138,25 +138,25 @@ void recv_server(void)
totalbytesread = 0; totalbytesread = 0;
while (totalbytesread < SENDSIZE) while (totalbytesread < SENDSIZE)
{ {
printf("server: Reading...\n"); message("server: Reading...\n");
nbytesread = recv(acceptsd, &buffer[totalbytesread], 1024 - totalbytesread, 0); nbytesread = recv(acceptsd, &buffer[totalbytesread], 1024 - totalbytesread, 0);
if (nbytesread <= 0) if (nbytesread <= 0)
{ {
printf("server: recv failed: %d\n", errno); message("server: recv failed: %d\n", errno);
close(listensd); close(listensd);
close(acceptsd); close(acceptsd);
exit(-1); exit(-1);
} }
totalbytesread += nbytesread; totalbytesread += nbytesread;
printf("server: Received %d of %d bytes\n", totalbytesread, SENDSIZE); message("server: Received %d of %d bytes\n", totalbytesread, SENDSIZE);
} }
/* Verify the message */ /* Verify the message */
if (totalbytesread != SENDSIZE) if (totalbytesread != SENDSIZE)
{ {
printf("server: Received %d / Expected %d bytes\n", totalbytesread, SENDSIZE); message("server: Received %d / Expected %d bytes\n", totalbytesread, SENDSIZE);
close(listensd); close(listensd);
close(acceptsd); close(acceptsd);
exit(-1); exit(-1);
@ -167,7 +167,7 @@ void recv_server(void)
{ {
if (buffer[i] != ch) if (buffer[i] != ch)
{ {
printf("server: Byte %d is %02x / Expected %02x\n", i, buffer[i], ch); message("server: Byte %d is %02x / Expected %02x\n", i, buffer[i], ch);
close(listensd); close(listensd);
close(acceptsd); close(acceptsd);
exit(-1); exit(-1);
@ -184,12 +184,12 @@ void recv_server(void)
nbytessent = send(acceptsd, buffer, totalbytesread, 0); nbytessent = send(acceptsd, buffer, totalbytesread, 0);
if (nbytessent <= 0) if (nbytessent <= 0)
{ {
printf("server: send failed: %d\n", errno); message("server: send failed: %d\n", errno);
close(listensd); close(listensd);
close(acceptsd); close(acceptsd);
exit(-1); exit(-1);
} }
printf("server: Sent %d bytes\n", nbytessent); message("server: Sent %d bytes\n", nbytessent);
close(listensd); close(listensd);
close(acceptsd); close(acceptsd);

13
examples/nettest/nettest.h
View File

@ -40,15 +40,28 @@
* Included Files * Included Files
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_NETTEST_HOST
#else
# include <debug.h>
#endif
/**************************************************************************** /****************************************************************************
* Definitions * Definitions
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_NETTEST_HOST #ifdef CONFIG_NETTEST_HOST
/* HTONS/L macros are unique to uIP */
# define HTONS(a) htons(a) # define HTONS(a) htons(a)
# define HTONL(a) htonl(a) # define HTONL(a) htonl(a)
# define message(...) printf(__VA_ARGS__)
#else #else
# define errno *get_errno_ptr() # define errno *get_errno_ptr()
# ifdef CONFIG_DEBUG
# define message(...) lib_lowprintf(__VA_ARGS__)
# else
# define message(...) printf(__VA_ARGS__)
# endif
#endif #endif
#define PORTNO 5471 #define PORTNO 5471

4
include/net/uip/uip-arch.h
View File

@ -169,8 +169,8 @@ struct uip_driver_s
/* Driver callbacks */ /* Driver callbacks */
int (*ifup)(struct uip_driver_s *dev); int (*d_ifup)(struct uip_driver_s *dev);
int (*ifdown)(struct uip_driver_s *dev); int (*d_ifdown)(struct uip_driver_s *dev);
/* Drivers may attached device-specific, private information */ /* Drivers may attached device-specific, private information */

14
net/connect.c
View File

@ -100,8 +100,11 @@ static inline int tcp_connect(FAR struct socket *psock, const struct sockaddr_in
static void connection_event(void *private) static void connection_event(void *private)
{ {
FAR struct socket *psock = (FAR struct socket *)private; FAR struct socket *psock = (FAR struct socket *)private;
if (psock) if (psock)
{ {
vdbg("uip_flags: %02x s_flags: %02x\n", uip_flags, psock->s_flags);
/* UIP_CLOSE: The remote host has closed the connection /* UIP_CLOSE: The remote host has closed the connection
* UIP_ABORT: The remote host has aborted the connection * UIP_ABORT: The remote host has aborted the connection
* UIP_TIMEDOUT: Connection aborted due to too many retransmissions. * UIP_TIMEDOUT: Connection aborted due to too many retransmissions.
@ -189,7 +192,7 @@ static void tcp_connect_interrupt(struct uip_driver_s *dev, void *private)
{ {
struct tcp_connect_s *pstate = (struct tcp_connect_s *)private; struct tcp_connect_s *pstate = (struct tcp_connect_s *)private;
vdbg("Interrupt uip_flags=%02x\n", uip_flags); vdbg("uip_flags: %02x\n", uip_flags);
/* 'private' might be null in some race conditions (?) */ /* 'private' might be null in some race conditions (?) */
@ -214,7 +217,6 @@ static void tcp_connect_interrupt(struct uip_driver_s *dev, void *private)
{ {
/* Indicate that remote host refused the connection */ /* Indicate that remote host refused the connection */
vdbg("ECONNREFUSED\n");
pstate->tc_result = -ECONNREFUSED; pstate->tc_result = -ECONNREFUSED;
} }
@ -224,7 +226,6 @@ static void tcp_connect_interrupt(struct uip_driver_s *dev, void *private)
{ {
/* Indicate that the remote host is unreachable (or should this be timedout?) */ /* Indicate that the remote host is unreachable (or should this be timedout?) */
vdbg("ETIMEDOUT\n");
pstate->tc_result = -ETIMEDOUT; pstate->tc_result = -ETIMEDOUT;
} }
@ -234,7 +235,6 @@ static void tcp_connect_interrupt(struct uip_driver_s *dev, void *private)
{ {
/* Indicate that the socket is no longer connected */ /* Indicate that the socket is no longer connected */
vdbg("Connected\n");
pstate->tc_result = OK; pstate->tc_result = OK;
} }
@ -245,6 +245,8 @@ static void tcp_connect_interrupt(struct uip_driver_s *dev, void *private)
return; return;
} }
vdbg("Resuming: %d\n", pstate->tc_result);
/* Stop further callbacks */ /* Stop further callbacks */
tcp_teardown_callbacks(pstate->tc_conn, pstate->tc_result); tcp_teardown_callbacks(pstate->tc_conn, pstate->tc_result);
@ -469,8 +471,6 @@ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{ {
case SOCK_STREAM: case SOCK_STREAM:
{ {
dbg("TCP\n");
/* Verify that the socket is not already connected */ /* Verify that the socket is not already connected */
if (_SS_ISCONNECTED(psock->s_flags)) if (_SS_ISCONNECTED(psock->s_flags))
@ -493,8 +493,6 @@ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
#ifdef CONFIG_NET_UDP #ifdef CONFIG_NET_UDP
case SOCK_DGRAM: case SOCK_DGRAM:
{ {
dbg("UDP\n");
ret = uip_udpconnect(psock->s_conn, inaddr); ret = uip_udpconnect(psock->s_conn, inaddr);
if (ret < 0) if (ret < 0)
{ {

47
net/netdev-ioctl.c
View File

@ -106,17 +106,17 @@ static void ioctl_setipaddr(uip_ipaddr_t *outaddr, struct sockaddr *inaddr)
static void ioctl_ifup(FAR struct uip_driver_s *dev) static void ioctl_ifup(FAR struct uip_driver_s *dev)
{ {
if (dev->ifup) if (dev->d_ifup)
{ {
dev->ifup(dev); dev->d_ifup(dev);
} }
} }
static void ioctl_ifdown(FAR struct uip_driver_s *dev) static void ioctl_ifdown(FAR struct uip_driver_s *dev)
{ {
if (dev->ifdown) if (dev->d_ifdown)
{ {
dev->ifdown(dev); dev->d_ifdown(dev);
} }
} }
@ -190,95 +190,56 @@ int netdev_ioctl(int sockfd, int cmd, struct ifreq *req)
{ {
case SIOCGIFADDR: /* Get IP address */ case SIOCGIFADDR: /* Get IP address */
ioctl_getipaddr(&req->ifr_addr, &dev->d_ipaddr); ioctl_getipaddr(&req->ifr_addr, &dev->d_ipaddr);
dbg("Dev: %s IP: %d.%d.%d.%d\n",
dev->d_ifname,
(dev->d_ipaddr >> 24) & 0xff, (dev->d_ipaddr >> 16) & 0xff,
(dev->d_ipaddr >> 8) & 0xff, dev->d_ipaddr & 0xff);
break; break;
case SIOCSIFADDR: /* Set IP address */ case SIOCSIFADDR: /* Set IP address */
ioctl_ifdown(dev); ioctl_ifdown(dev);
ioctl_setipaddr(&dev->d_ipaddr, &req->ifr_addr); ioctl_setipaddr(&dev->d_ipaddr, &req->ifr_addr);
dbg("Dev: %s IP: %d.%d.%d.%d\n",
dev->d_ifname,
(dev->d_ipaddr >> 24) & 0xff, (dev->d_ipaddr >> 16) & 0xff,
(dev->d_ipaddr >> 8) & 0xff, dev->d_ipaddr & 0xff);
ioctl_ifup(dev); ioctl_ifup(dev);
break; break;
case SIOCGIFDSTADDR: /* Get P-to-P address */ case SIOCGIFDSTADDR: /* Get P-to-P address */
ioctl_getipaddr(&req->ifr_dstaddr, &dev->d_draddr); ioctl_getipaddr(&req->ifr_dstaddr, &dev->d_draddr);
dbg("Dev: %s Default router: %d.%d.%d.%d\n",
dev->d_ifname,
(dev->d_draddr >> 24) & 0xff, (dev->d_draddr >> 16) & 0xff,
(dev->d_draddr >> 8) & 0xff, dev->d_draddr & 0xff);
break; break;
case SIOCSIFDSTADDR: /* Set P-to-P address */ case SIOCSIFDSTADDR: /* Set P-to-P address */
ioctl_setipaddr(&dev->d_draddr, &req->ifr_dstaddr); ioctl_setipaddr(&dev->d_draddr, &req->ifr_dstaddr);
dbg("Dev: %s Default router: %d.%d.%d.%d\n",
dev->d_ifname,
(dev->d_draddr >> 24) & 0xff, (dev->d_draddr >> 16) & 0xff,
(dev->d_draddr >> 8) & 0xff, dev->d_draddr & 0xff);
break; break;
case SIOCGIFNETMASK: /* Get network mask */ case SIOCGIFNETMASK: /* Get network mask */
ioctl_getipaddr(&req->ifr_addr, &dev->d_netmask); ioctl_getipaddr(&req->ifr_addr, &dev->d_netmask);
dbg("Dev: %s Netmask: %d.%d.%d.%d\n",
dev->d_ifname,
(dev->d_netmask >> 24) & 0xff, (dev->d_netmask >> 16) & 0xff,
(dev->d_netmask >> 8) & 0xff, dev->d_netmask & 0xff);
break; break;
case SIOCSIFNETMASK: /* Set network mask */ case SIOCSIFNETMASK: /* Set network mask */
ioctl_setipaddr(&dev->d_netmask, &req->ifr_addr); ioctl_setipaddr(&dev->d_netmask, &req->ifr_addr);
dbg("Dev: %s Netmask: %d.%d.%d.%d\n",
dev->d_ifname,
(dev->d_netmask >> 24) & 0xff, (dev->d_netmask >> 16) & 0xff,
(dev->d_netmask >> 8) & 0xff, dev->d_netmask & 0xff);
break; break;
case SIOCGIFMTU: /* Get MTU size */ case SIOCGIFMTU: /* Get MTU size */
req->ifr_mtu = UIP_BUFSIZE; req->ifr_mtu = UIP_BUFSIZE;
dbg("Dev: %s MTU: %d\n", dev->d_ifname, UIP_BUFSIZE);
break; break;
case SIOCGIFHWADDR: /* Get hardware address */ case SIOCGIFHWADDR: /* Get hardware address */
req->ifr_hwaddr.sa_family = AF_INETX; req->ifr_hwaddr.sa_family = AF_INETX;
memcpy(req->ifr_hwaddr.sa_data, dev->d_mac.addr, IFHWADDRLEN); memcpy(req->ifr_hwaddr.sa_data, dev->d_mac.addr, IFHWADDRLEN);
dbg("Dev: %s MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
dev->d_ifname,
dev->d_mac.addr[0], dev->d_mac.addr[1], dev->d_mac.addr[2],
dev->d_mac.addr[3], dev->d_mac.addr[4], dev->d_mac.addr[5]);
break; break;
case SIOCSIFHWADDR: /* Set hardware address */ case SIOCSIFHWADDR: /* Set hardware address */
req->ifr_hwaddr.sa_family = AF_INETX; req->ifr_hwaddr.sa_family = AF_INETX;
memcpy(dev->d_mac.addr, req->ifr_hwaddr.sa_data, IFHWADDRLEN); memcpy(dev->d_mac.addr, req->ifr_hwaddr.sa_data, IFHWADDRLEN);
dbg("Dev: %s MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
dev->d_ifname,
dev->d_mac.addr[0], dev->d_mac.addr[1], dev->d_mac.addr[2],
dev->d_mac.addr[3], dev->d_mac.addr[4], dev->d_mac.addr[5]);
break; break;
case SIOCDIFADDR: /* Delete IP address */ case SIOCDIFADDR: /* Delete IP address */
ioctl_ifdown(dev); ioctl_ifdown(dev);
memset(&dev->d_ipaddr, 0, sizeof(uip_ipaddr_t)); memset(&dev->d_ipaddr, 0, sizeof(uip_ipaddr_t));
dbg("Dev: %s IP: %d.%d.%d.%d\n",
dev->d_ifname,
(dev->d_ipaddr >> 24) & 0xff, (dev->d_ipaddr >> 16) & 0xff,
(dev->d_ipaddr >> 8) & 0xff, dev->d_ipaddr & 0xff);
break; break;
case SIOCGIFCOUNT: /* Get number of devices */ case SIOCGIFCOUNT: /* Get number of devices */
req->ifr_count = netdev_count(); req->ifr_count = netdev_count();
dbg("Dev: %s I/F count: %d\n", netdev_count());
err = ENOSYS; err = ENOSYS;
break; break;
case SIOCGIFBRDADDR: /* Get broadcast IP address */ case SIOCGIFBRDADDR: /* Get broadcast IP address */
case SIOCSIFBRDADDR: /* Set broadcast IP address */ case SIOCSIFBRDADDR: /* Set broadcast IP address */
dbg("Dev: %s Broadcast: 255.255.255.255d\n", dev->d_ifname);
err = ENOSYS; err = ENOSYS;
goto errout; goto errout;

14
net/recvfrom.c
View File

@ -107,7 +107,7 @@ static void recvfrom_interrupt(struct uip_driver_s *dev, void *private)
#endif #endif
size_t recvlen; size_t recvlen;
vdbg("Interrupt uip_flags: %02x\n", uip_flags); vdbg("uip_flags: %02x\n", uip_flags);
/* 'private' might be null in some race conditions (?) */ /* 'private' might be null in some race conditions (?) */
@ -154,7 +154,7 @@ static void recvfrom_interrupt(struct uip_driver_s *dev, void *private)
{ {
struct uip_udp_conn *udp_conn; struct uip_udp_conn *udp_conn;
vdbg("UDP complete\n"); vdbg("UDP resume\n");
/* Don't allow any further UDP call backs. */ /* Don't allow any further UDP call backs. */
@ -174,7 +174,7 @@ static void recvfrom_interrupt(struct uip_driver_s *dev, void *private)
{ {
struct uip_conn *conn; struct uip_conn *conn;
vdbg("TCP complete\n"); vdbg("TCP resume\n");
/* The TCP receive buffer is full. Return now, perhaps truncating /* The TCP receive buffer is full. Return now, perhaps truncating
* the received data (need to fix that). * the received data (need to fix that).
@ -206,7 +206,7 @@ static void recvfrom_interrupt(struct uip_driver_s *dev, void *private)
else if ((uip_flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0) else if ((uip_flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0)
{ {
vdbg("Receive error\n"); vdbg("error\n");
/* Stop further callbacks */ /* Stop further callbacks */
@ -480,9 +480,7 @@ static ssize_t udp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len,
* and automatically re-enabled when the task restarts. * and automatically re-enabled when the task restarts.
*/ */
vdbg("Receiving UDP ...\n");
ret = sem_wait(&state. rf_sem); ret = sem_wait(&state. rf_sem);
vdbg("Received\n");
/* Make sure that no further interrupts are processed */ /* Make sure that no further interrupts are processed */
@ -531,7 +529,7 @@ static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len,
/* Verify that the SOCK_STREAM has been connected */ /* Verify that the SOCK_STREAM has been connected */
if (_SS_ISCONNECTED(psock->s_flags)) if (!_SS_ISCONNECTED(psock->s_flags))
{ {
/* The SOCK_STREAM must be connected in order to receive */ /* The SOCK_STREAM must be connected in order to receive */
@ -559,9 +557,7 @@ static ssize_t tcp_recvfrom(FAR struct socket *psock, FAR void *buf, size_t len,
* and automatically re-enabled when the task restarts. * and automatically re-enabled when the task restarts.
*/ */
vdbg("Receiving UDP ...\n");
ret = sem_wait(&state.rf_sem); ret = sem_wait(&state.rf_sem);
vdbg("Received\n");
/* Make sure that no further interrupts are processed */ /* Make sure that no further interrupts are processed */

10
net/send.c
View File

@ -104,7 +104,7 @@ static void send_interrupt(struct uip_driver_s *dev, void *private)
struct send_s *pstate = (struct send_s *)private; struct send_s *pstate = (struct send_s *)private;
struct uip_conn *conn; struct uip_conn *conn;
vdbg("Interrupt uip_flags: %02x state: %d\n", uip_flags, pstate->snd_state); vdbg("uip_flags: %02x state: %d\n", uip_flags, pstate->snd_state);
/* If the data has not been sent OR if it needs to be retransmitted, /* If the data has not been sent OR if it needs to be retransmitted,
* then send it now. * then send it now.
@ -122,7 +122,6 @@ static void send_interrupt(struct uip_driver_s *dev, void *private)
} }
pstate->snd_state = STATE_DATA_SENT; pstate->snd_state = STATE_DATA_SENT;
vdbg("state: STATE_DATA_SENT(%d)\n", STATE_DATA_SENT);
} }
/* Check if all data has been sent and acknowledged */ /* Check if all data has been sent and acknowledged */
@ -142,12 +141,9 @@ static void send_interrupt(struct uip_driver_s *dev, void *private)
/* Send again on the next poll */ /* Send again on the next poll */
pstate->snd_state = STATE_POLLWAIT; pstate->snd_state = STATE_POLLWAIT;
vdbg("state: STATE_POLLWAIT(%d)\n", STATE_POLLWAIT);
} }
else else
{ {
vdbg("state: Data sent\n");
/* All data has been sent */ /* All data has been sent */
pstate->snd_sent += pstate->snd_buflen; pstate->snd_sent += pstate->snd_buflen;
@ -172,8 +168,6 @@ static void send_interrupt(struct uip_driver_s *dev, void *private)
else if ((uip_flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0) else if ((uip_flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0)
{ {
vdbg("state: TCP failure\n");
/* Stop further callbacks */ /* Stop further callbacks */
conn = (struct uip_conn *)pstate->snd_sock->s_conn; conn = (struct uip_conn *)pstate->snd_sock->s_conn;
@ -316,14 +310,12 @@ ssize_t send(int sockfd, const void *buf, size_t len, int flags)
* automatically re-enabled when the task restarts. * automatically re-enabled when the task restarts.
*/ */
vdbg("Sending %d bytes...\n", len);
ret = sem_wait(&state. snd_sem); ret = sem_wait(&state. snd_sem);
/* Make sure that no further interrupts are processed */ /* Make sure that no further interrupts are processed */
conn->data_private = NULL; conn->data_private = NULL;
conn->data_event = NULL; conn->data_event = NULL;
vdbg("Sent\n");
} }
sem_destroy(&state. snd_sem); sem_destroy(&state. snd_sem);

17
net/uip/uip-arp.c
View File

@ -137,19 +137,19 @@ static uint8 g_arptime;
* Private Functions * Private Functions
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_DEBUG_VERBOSE #if defined(CONFIG_NET_DUMPARP) && defined(CONFIG_DEBUG)
static void uip_arp_dump(struct arp_hdr *arp) static void uip_arp_dump(struct arp_hdr *arp)
{ {
vdbg(" HW type: %04x Protocol: %04x\n", dbg(" HW type: %04x Protocol: %04x\n",
arp->ah_hwtype, arp->ah_protocol);\ arp->ah_hwtype, arp->ah_protocol);\
vdbg(" HW len: %02x Proto len: %02x Operation: %04x\n", dbg(" HW len: %02x Proto len: %02x Operation: %04x\n",
arp->ah_hwlen, arp->ah_protolen, arp->ah_opcode); arp->ah_hwlen, arp->ah_protolen, arp->ah_opcode);
vdbg(" Sender MAC: %02x:%02x:%02x:%02x:%02x:%02x IP: %d.%d.%d.%d\n", dbg(" Sender MAC: %02x:%02x:%02x:%02x:%02x:%02x IP: %d.%d.%d.%d\n",
arp->ah_shwaddr[0], arp->ah_shwaddr[1], arp->ah_shwaddr[2], arp->ah_shwaddr[0], arp->ah_shwaddr[1], arp->ah_shwaddr[2],
arp->ah_shwaddr[3], arp->ah_shwaddr[4], arp->ah_shwaddr[5], arp->ah_shwaddr[3], arp->ah_shwaddr[4], arp->ah_shwaddr[5],
arp->ah_sipaddr[0] & 0xff, arp->ah_sipaddr[0] >> 8, arp->ah_sipaddr[0] & 0xff, arp->ah_sipaddr[0] >> 8,
arp->ah_sipaddr[1] & 0xff, arp->ah_sipaddr[1] >> 8); arp->ah_sipaddr[1] & 0xff, arp->ah_sipaddr[1] >> 8);
vdbg(" Dest MAC: %02x:%02x:%02x:%02x:%02x:%02x IP: %d.%d.%d.%d\n", dbg(" Dest MAC: %02x:%02x:%02x:%02x:%02x:%02x IP: %d.%d.%d.%d\n",
arp->ah_dhwaddr[0], arp->ah_dhwaddr[1], arp->ah_dhwaddr[2], arp->ah_dhwaddr[0], arp->ah_dhwaddr[1], arp->ah_dhwaddr[2],
arp->ah_dhwaddr[3], arp->ah_dhwaddr[4], arp->ah_dhwaddr[5], arp->ah_dhwaddr[3], arp->ah_dhwaddr[4], arp->ah_dhwaddr[5],
arp->ah_dipaddr[0] & 0xff, arp->ah_dipaddr[0] >> 8, arp->ah_dipaddr[0] & 0xff, arp->ah_dipaddr[0] >> 8,
@ -449,12 +449,6 @@ void uip_arp_out(struct uip_driver_s *dev)
uip_ipaddr_copy(ipaddr, destipaddr); uip_ipaddr_copy(ipaddr, destipaddr);
} }
vdbg("Dest IP addr: %d.%d.%d.%d -> ARP IP addr: %d.%d.%d.%d\n",
(destipaddr >> 24) & 0xff, (destipaddr >> 16) & 0xff,
(destipaddr >> 8) & 0xff, destipaddr & 0xff,
(ipaddr >> 24) & 0xff, (ipaddr >> 16) & 0xff,
(ipaddr >> 8) & 0xff, ipaddr & 0xff);
/* Check if we already have this destination address in the ARP table */ /* Check if we already have this destination address in the ARP table */
for (i = 0; i < UIP_ARPTAB_SIZE; ++i) for (i = 0; i < UIP_ARPTAB_SIZE; ++i)
@ -462,7 +456,6 @@ void uip_arp_out(struct uip_driver_s *dev)
tabptr = &arp_table[i]; tabptr = &arp_table[i];
if (uip_ipaddr_cmp(ipaddr, tabptr->at_ipaddr)) if (uip_ipaddr_cmp(ipaddr, tabptr->at_ipaddr))
{ {
vdbg("Dest IP found in ARP table\n");
break; break;
} }
} }

2
net/uip/uip-fw.c
View File

@ -323,7 +323,7 @@ uint8 uip_fw_output(struct uip_driver_s *dev)
#endif /* UIP_BROADCAST */ #endif /* UIP_BROADCAST */
netif = find_netif (dev); netif = find_netif (dev);
dbg("uip_fw_output: netif %p ->output %p len %d\n", netif, netif->output, dev->d_len); dbg("netif: %p output: %p len: %d\n", netif, netif->output, dev->d_len);
if (netif == NULL) { if (netif == NULL) {
return UIP_FW_NOROUTE; return UIP_FW_NOROUTE;

12
net/uip/uip-neighbor.c
View File

@ -81,9 +81,9 @@ void uip_neighbor_add(uip_ipaddr_t ipaddr, struct uip_neighbor_addr *addr)
int i, oldest; int i, oldest;
uint8 oldest_time; uint8 oldest_time;
dbg("Adding neighbor with link address %02x:%02x:%02x:%02x:%02x:%02x\n", dbg("Add neighbor: %02x:%02x:%02x:%02x:%02x:%02x\n",
addr->addr.addr[0], addr->addr.addr[1], addr->addr.addr[2], addr->addr.addr[3], addr->addr.addr[0], addr->addr.addr[1], addr->addr.addr[2],
addr->addr.addr[4], addr->addr.addr[5]); addr->addr.addr[3], addr->addr.addr[4], addr->addr.addr[5]);
/* Find the first unused entry or the oldest used entry. */ /* Find the first unused entry or the oldest used entry. */
@ -149,9 +149,9 @@ struct uip_neighbor_addr *uip_neighbor_lookup(uip_ipaddr_t ipaddr)
e = find_entry(ipaddr); e = find_entry(ipaddr);
if (e != NULL) if (e != NULL)
{ {
dbg("Lookup neighbor with link address %02x:%02x:%02x:%02x:%02x:%02x\n", dbg("Lookup neighbor: %02x:%02x:%02x:%02x:%02x:%02x\n",
e->addr.addr.addr[0], e->addr.addr.addr[1], e->addr.addr.addr[2], e->addr.addr.addr[3], e->addr.addr.addr[0], e->addr.addr.addr[1], e->addr.addr.addr[2],
e->addr.addr.addr[4], e->addr.addr.addr[5]); e->addr.addr.addr[3], e->addr.addr.addr[4], e->addr.addr.addr[5]);
return &e->addr; return &e->addr;
} }

4
net/uip/uip-poll.c
View File

@ -125,7 +125,7 @@ int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback, int event)
/* Traverse all of the active TCP connections and perform the poll action */ /* Traverse all of the active TCP connections and perform the poll action */
conn = NULL; conn = NULL;
while ((conn = uip_nexttcpconn(uip_conn))) while ((conn = uip_nexttcpconn(conn)))
{ {
uip_conn = conn; uip_conn = conn;
uip_interrupt(dev, event); uip_interrupt(dev, event);
@ -141,7 +141,7 @@ int uip_poll(struct uip_driver_s *dev, uip_poll_callback_t callback, int event)
/* Traverse all of the allocated UDP connections and perform a poll action */ /* Traverse all of the allocated UDP connections and perform a poll action */
udp_conn = NULL; udp_conn = NULL;
while ((udp_conn = uip_nextudpconn(uip_udp_conn))) while ((udp_conn = uip_nextudpconn(udp_conn)))
{ {
uip_udp_conn = udp_conn; uip_udp_conn = udp_conn;
uip_interrupt(dev, UIP_UDP_POLL); uip_interrupt(dev, UIP_UDP_POLL);

10
net/uip/uip-tcpconn.c
View File

@ -321,20 +321,10 @@ struct uip_conn *uip_tcpactive(struct uip_tcpip_hdr *buf)
struct uip_conn *conn = (struct uip_conn *)g_active_tcp_connections.head; struct uip_conn *conn = (struct uip_conn *)g_active_tcp_connections.head;
in_addr_t srcipaddr = uip_ip4addr_conv(buf->srcipaddr); in_addr_t srcipaddr = uip_ip4addr_conv(buf->srcipaddr);
vdbg("BUF: destport: %04x srcport: %04x IP: %d.%d.%d.%d\n",
buf->destport, buf->srcport,
(srcipaddr >> 24) & 0xff, (srcipaddr >> 16) & 0xff,
(srcipaddr >> 8) & 0xff, srcipaddr & 0xff);
while (conn) while (conn)
{ {
/* Find an open connection matching the tcp input */ /* Find an open connection matching the tcp input */
vdbg("conn: lport: %04x rport: %04x IP: %d.%d.%d.%d\n",
conn->lport, conn->rport,
(conn->ripaddr >> 24) & 0xff, (conn->ripaddr >> 16) & 0xff,
(conn->ripaddr >> 8) & 0xff, conn->ripaddr & 0xff);
if (conn->tcpstateflags != UIP_CLOSED && if (conn->tcpstateflags != UIP_CLOSED &&
buf->destport == conn->lport && buf->srcport == conn->rport && buf->destport == conn->lport && buf->srcport == conn->rport &&
uip_ipaddr_cmp(srcipaddr, conn->ripaddr)) uip_ipaddr_cmp(srcipaddr, conn->ripaddr))

39
net/uip/uip.c
View File

@ -333,7 +333,6 @@ uint16 uip_ipchksum(struct uip_driver_s *dev)
uint16 sum; uint16 sum;
sum = chksum(0, &dev->d_buf[UIP_LLH_LEN], UIP_IPH_LEN); sum = chksum(0, &dev->d_buf[UIP_LLH_LEN], UIP_IPH_LEN);
vdbg("Checksum 0x%04x\n", sum);
return (sum == 0) ? 0xffff : htons(sum); return (sum == 0) ? 0xffff : htons(sum);
} }
#endif #endif
@ -537,7 +536,7 @@ static void uip_add_rcv_nxt(uint16 n)
#ifdef CONFIG_NET_UDP #ifdef CONFIG_NET_UDP
static void uip_udp_callback(struct uip_driver_s *dev) static void uip_udp_callback(struct uip_driver_s *dev)
{ {
vdbg("UDP callback uip_flags: %02x\n", uip_flags); vdbg("uip_flags: %02x\n", uip_flags);
/* Some sanity checking */ /* Some sanity checking */
@ -552,7 +551,7 @@ static void uip_udp_callback(struct uip_driver_s *dev)
static void uip_tcp_callback(struct uip_driver_s *dev) static void uip_tcp_callback(struct uip_driver_s *dev)
{ {
vdbg("TCP callback uip_flags: %02x\n", uip_flags); vdbg("uip_flags: %02x\n", uip_flags);
/* Some sanity checking */ /* Some sanity checking */
@ -588,6 +587,8 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 event)
int len; int len;
int i; int i;
vdbg("event: %d\n", event);
dev->d_snddata = dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; dev->d_snddata = dev->d_appdata = &dev->d_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
/* Check if we were invoked because of a poll request for a /* Check if we were invoked because of a poll request for a
@ -596,7 +597,6 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 event)
if (event == UIP_POLL_REQUEST) if (event == UIP_POLL_REQUEST)
{ {
vdbg("event: UIP_POLL_REQUEST\n");
if ((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED && if ((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&
!uip_outstanding(uip_connr)) !uip_outstanding(uip_connr))
{ {
@ -761,7 +761,6 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 event)
/* This is where the input processing starts. */ /* This is where the input processing starts. */
vdbg("event: %d\n", event);
UIP_STAT(++uip_stat.ip.recv); UIP_STAT(++uip_stat.ip.recv);
/* Start of IP input header processing code. */ /* Start of IP input header processing code. */
@ -867,10 +866,7 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 event)
*/ */
#if UIP_BROADCAST #if UIP_BROADCAST
vdbg("UDP IP checksum 0x%04x\n", uip_ipchksum(dev)); if (BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr)
if (BUF->proto == UIP_PROTO_UDP &&
uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr)
/*&& uip_ipchksum(dev) == 0xffff*/)
{ {
goto udp_input; goto udp_input;
} }
@ -941,7 +937,6 @@ void uip_interrupt(struct uip_driver_s *dev, uint8 event)
#if UIP_PINGADDRCONF #if UIP_PINGADDRCONF
icmp_input: icmp_input:
vdbg("icmp_input\n");
#endif /* UIP_PINGADDRCONF */ #endif /* UIP_PINGADDRCONF */
UIP_STAT(++uip_stat.icmp.recv); UIP_STAT(++uip_stat.icmp.recv);
@ -992,8 +987,6 @@ icmp_input:
/* This is IPv6 ICMPv6 processing code. */ /* This is IPv6 ICMPv6 processing code. */
vdbg("ICMP6 input length %d\n", dev->d_len);
if (BUF->proto != UIP_PROTO_ICMP6) if (BUF->proto != UIP_PROTO_ICMP6)
{ {
/* We only allow ICMPv6 packets from here. */ /* We only allow ICMPv6 packets from here. */
@ -1060,7 +1053,6 @@ icmp_input:
} }
else else
{ {
vdbg("Unknown ICMP6 message: %d\n", ICMPBUF->type);
UIP_STAT(++uip_stat.icmp.drop); UIP_STAT(++uip_stat.icmp.drop);
UIP_STAT(++uip_stat.icmp.typeerr); UIP_STAT(++uip_stat.icmp.typeerr);
UIP_LOG("icmp: unknown ICMP message."); UIP_LOG("icmp: unknown ICMP message.");
@ -1072,7 +1064,6 @@ icmp_input:
/* UDP input processing. */ /* UDP input processing. */
udp_input: udp_input:
vdbg("udp_input\n");
/* UDP processing is really just a hack. We don't do anything to the /* UDP processing is really just a hack. We don't do anything to the
* UDP/IP headers, but let the UDP application do all the hard * UDP/IP headers, but let the UDP application do all the hard
@ -1106,7 +1097,6 @@ udp_input:
goto drop; goto drop;
udp_found: udp_found:
vdbg("udp_found\n");
uip_conn = NULL; uip_conn = NULL;
uip_flags = UIP_NEWDATA; uip_flags = UIP_NEWDATA;
@ -1115,7 +1105,7 @@ udp_found:
uip_udp_callback(dev); uip_udp_callback(dev);
udp_send: udp_send:
vdbg("udp_send\n");
if (dev->d_sndlen == 0) if (dev->d_sndlen == 0)
{ {
goto drop; goto drop;
@ -1164,7 +1154,6 @@ udp_send:
/* TCP input processing. */ /* TCP input processing. */
tcp_input: tcp_input:
vdbg("tcp_input\n");
UIP_STAT(++uip_stat.tcp.recv); UIP_STAT(++uip_stat.tcp.recv);
@ -1213,7 +1202,6 @@ tcp_input:
UIP_STAT(++uip_stat.tcp.synrst); UIP_STAT(++uip_stat.tcp.synrst);
reset: reset:
vdbg("reset\n");
/* We do not send resets in response to resets. */ /* We do not send resets in response to resets. */
@ -1283,7 +1271,6 @@ reset:
*/ */
found_listen: found_listen:
vdbg("found_listen\n");
/* First allocate a new connection structure and see if there is any /* First allocate a new connection structure and see if there is any
* user application to accept it. * user application to accept it.
@ -1377,11 +1364,9 @@ found_listen:
/* Our response will be a SYNACK. */ /* Our response will be a SYNACK. */
tcp_send_synack: tcp_send_synack:
vdbg("tcp_send_synack\n");
BUF->flags = TCP_ACK; BUF->flags = TCP_ACK;
tcp_send_syn: tcp_send_syn:
vdbg("tcp_send_syn\n");
BUF->flags |= TCP_SYN; BUF->flags |= TCP_SYN;
/* We send out the TCP Maximum Segment Size option with our SYNACK. */ /* We send out the TCP Maximum Segment Size option with our SYNACK. */
@ -1397,7 +1382,6 @@ tcp_send_syn:
/* This label will be jumped to if we found an active connection. */ /* This label will be jumped to if we found an active connection. */
found: found:
vdbg("found\n");
uip_conn = uip_connr; uip_conn = uip_connr;
uip_flags = 0; uip_flags = 0;
@ -1671,7 +1655,6 @@ found:
vdbg("TCP state: UIP_LAST_ACK\n"); vdbg("TCP state: UIP_LAST_ACK\n");
tcp_send_finack: tcp_send_finack:
vdbg("tcp_send_finack\n");
BUF->flags = TCP_FIN | TCP_ACK; BUF->flags = TCP_FIN | TCP_ACK;
goto tcp_send_nodata; goto tcp_send_nodata;
@ -1763,7 +1746,6 @@ tcp_send_finack:
uip_tcp_callback(dev); uip_tcp_callback(dev);
appsend: appsend:
vdbg("appsend\n");
if (uip_flags & UIP_ABORT) if (uip_flags & UIP_ABORT)
{ {
@ -1836,7 +1818,6 @@ appsend:
} }
uip_connr->nrtx = 0; uip_connr->nrtx = 0;
apprexmit: apprexmit:
vdbg("apprexmit\n");
dev->d_appdata = dev->d_snddata; dev->d_appdata = dev->d_snddata;
/* If the application has data to be sent, or if the incoming /* If the application has data to be sent, or if the incoming
@ -1972,19 +1953,16 @@ apprexmit:
*/ */
tcp_send_ack: tcp_send_ack:
vdbg("tcp_send_ack\n");
BUF->flags = TCP_ACK; BUF->flags = TCP_ACK;
tcp_send_nodata: tcp_send_nodata:
vdbg("tcp_send_nodata\n");
dev->d_len = UIP_IPTCPH_LEN; dev->d_len = UIP_IPTCPH_LEN;
tcp_send_noopts: tcp_send_noopts:
BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4; BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
tcp_send: tcp_send:
vdbg("tcp_send\n");
/* We're done with the input processing. We are now ready to send a /* We're done with the input processing. We are now ready to send a
* reply. Our job is to fill in all the fields of the TCP and IP * reply. Our job is to fill in all the fields of the TCP and IP
@ -2025,7 +2003,6 @@ tcp_send:
} }
tcp_send_noconn: tcp_send_noconn:
vdbg("tcp_send_noconn\n");
BUF->ttl = UIP_TTL; BUF->ttl = UIP_TTL;
#ifdef CONFIG_NET_IPv6 #ifdef CONFIG_NET_IPv6
@ -2049,7 +2026,6 @@ tcp_send_noconn:
#ifdef CONFIG_NET_UDP #ifdef CONFIG_NET_UDP
ip_send_nolen: ip_send_nolen:
vdbg("ip_send_nolen\n");
#endif /* CONFIG_NET_UDP */ #endif /* CONFIG_NET_UDP */
#ifdef CONFIG_NET_IPv6 #ifdef CONFIG_NET_IPv6
@ -2069,13 +2045,12 @@ ip_send_nolen:
BUF->ipchksum = 0; BUF->ipchksum = 0;
BUF->ipchksum = ~(uip_ipchksum(dev)); BUF->ipchksum = ~(uip_ipchksum(dev));
vdbg("checksum: 0x%04x\n", uip_ipchksum(dev));
#endif /* CONFIG_NET_IPv6 */ #endif /* CONFIG_NET_IPv6 */
UIP_STAT(++uip_stat.tcp.sent); UIP_STAT(++uip_stat.tcp.sent);
send: send:
vdbg("send: packet length %d (%d)\n", vdbg("Sending packet length %d (%d)\n",
dev->d_len, (BUF->len[0] << 8) | BUF->len[1]); dev->d_len, (BUF->len[0] << 8) | BUF->len[1]);
UIP_STAT(++uip_stat.ip.sent); UIP_STAT(++uip_stat.ip.sent);