libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

use tcpip_init_done_callback to initialize lwip stack. 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1668 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
bernard.xiong 2011-08-11 10:05:37 +00:00
parent 922b40f614
commit 5a825fd81a
4 changed files with 138 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
components/net/lwip/src/arch/include/arch/sys_arch_init.h
View File

@ -1,6 +1,8 @@
#ifndef __LWIP_SYS_INIT_H__
#define __LWIP_SYS_INIT_H__
void lwip_sys_init();
void lwip_sys_init(void);
void lwip_system_init(void);
#endif

162
components/net/lwip/src/arch/sys_arch_init.c
View File

@ -1,7 +1,4 @@
#include <rtthread.h>
#ifdef RT_USING_FINSH
#include <finsh.h>
#endif
#include "lwip/debug.h"
#include "lwip/mem.h"
@ -14,55 +11,136 @@
#include "netif/ethernetif.h"
#include "netif/etharp.h"
/*
* lwip system initial entry
*/
void lwip_sys_init()
{
struct ip_addr ipaddr, netmask, gw;
/* introduce from kservice.c */
#define rt_list_entry(node, type, member) \
((type *)((char *)(node) - (unsigned long)(&((type *)0)->member)))
#if LWIP_DHCP
rt_uint32_t mscnt = 0;
static err_t netif_device_init(struct netif *netif)
{
struct eth_device *ethif;
ethif = (struct eth_device*)netif->state;
if (ethif != RT_NULL)
{
rt_device_t device;
/* get device object */
device = (rt_device_t) ethif;
if (rt_device_init(device) != RT_EOK)
{
return ERR_IF;
}
return ERR_OK;
}
return ERR_IF;
}
static void tcpip_init_done_callback(void *arg)
{
rt_device_t device;
struct eth_device *ethif;
struct ip_addr ipaddr, netmask, gw;
struct rt_list_node* node;
struct rt_object* object;
struct rt_object_information *information;
extern struct rt_object_information rt_object_container[];
LWIP_ASSERT("invalid arg.\n",arg);
IP4_ADDR(&gw, 0,0,0,0);
IP4_ADDR(&ipaddr, 0,0,0,0);
IP4_ADDR(&netmask, 0,0,0,0);
#else
IP4_ADDR(&ipaddr, RT_LWIP_IPADDR0, RT_LWIP_IPADDR1, RT_LWIP_IPADDR2, RT_LWIP_IPADDR3);
IP4_ADDR(&gw, RT_LWIP_GWADDR0, RT_LWIP_GWADDR1, RT_LWIP_GWADDR2, RT_LWIP_GWADDR3);
IP4_ADDR(&netmask, RT_LWIP_MSKADDR0, RT_LWIP_MSKADDR1, RT_LWIP_MSKADDR2, RT_LWIP_MSKADDR3);
#endif
tcpip_init(RT_NULL, RT_NULL);
/* enter critical */
rt_enter_critical();
netif_set_addr(netif_default, &ipaddr, &netmask, &gw);
netif_set_up(netif_default);
/* for each network interfaces */
information = &rt_object_container[RT_Object_Class_Device];
for (node = information->object_list.next; node != &(information->object_list); node = node->next)
{
object = rt_list_entry(node, struct rt_object, list);
device = (rt_device_t) object;
if (device->type == RT_Device_Class_NetIf)
{
ethif = (struct eth_device*)device;
/* leave critical */
rt_exit_critical();
netif_add(ethif->netif, &ipaddr, &netmask, &gw,
ethif, netif_device_init, tcpip_input);
if (netif_default == RT_NULL)
netif_set_default(ethif->netif);
#if LWIP_DHCP
/* use DHCP client */
dhcp_start(netif_default);
while (netif_default->ip_addr.addr == 0)
{
rt_thread_delay(DHCP_FINE_TIMER_MSECS * RT_TICK_PER_SECOND / 1000);
dhcp_fine_tmr();
mscnt += DHCP_FINE_TIMER_MSECS;
if (mscnt >= DHCP_COARSE_TIMER_SECS*1000)
{
dhcp_coarse_tmr();
mscnt = 0;
}
}
rt_kprintf("Acquired IP address from DHCP server:");
rt_kprintf("%d.%d.%d.%d\n", netif_default->ip_addr.addr & 0xff,
(netif_default->ip_addr.addr>>8) & 0xff,
(netif_default->ip_addr.addr>>16) & 0xff,
(netif_default->ip_addr.addr>>24) & 0xff);
dhcp_start(ethif->netif);
#else
netif_set_up(ethif->netif);
#endif
#if defined(RT_USING_FINSH) && (LWIP_STATS_DISPLAY)
finsh_syscall_append("lwip_info", (syscall_func)stats_display);
#ifdef LWIP_NETIF_LINK_CALLBACK
netif_set_link_up(ethif->netif);
#endif
/* enter critical */
rt_enter_critical();
}
}
/* leave critical */
rt_exit_critical();
rt_sem_release((rt_sem_t)arg);
}
/**
* LwIP system initialization
*/
void lwip_system_init(void)
{
rt_err_t rc;
struct rt_semaphore done_sem;
rc = rt_sem_init(&done_sem, "done", 0, RT_IPC_FLAG_FIFO);
if(rc != RT_EOK)
{
LWIP_ASSERT("Failed to create semaphore", 0);
return;
}
tcpip_init(tcpip_init_done_callback,(void *)&done_sem);
/* waiting for initialization done */
if (rt_sem_take(&done_sem, RT_WAITING_FOREVER) != RT_EOK)
{
rt_sem_detach(&done_sem);
return;
}
rt_sem_detach(&done_sem);
/* set default ip address */
#if !LWIP_DHCP
{
struct ip_addr ipaddr, netmask, gw;
IP4_ADDR(&ipaddr, RT_LWIP_IPADDR0, RT_LWIP_IPADDR1, RT_LWIP_IPADDR2, RT_LWIP_IPADDR3);
IP4_ADDR(&gw, RT_LWIP_GWADDR0, RT_LWIP_GWADDR1, RT_LWIP_GWADDR2, RT_LWIP_GWADDR3);
IP4_ADDR(&netmask, RT_LWIP_MSKADDR0, RT_LWIP_MSKADDR1, RT_LWIP_MSKADDR2, RT_LWIP_MSKADDR3);
netifapi_netif_set_addr(netif_default, &ipaddr, &netmask, &gw);
}
#endif
}
/**
* Compatible with RT-Thread 0.2.x/0.3.x
*/
void lwip_sys_init(void)
{
lwip_system_init();
}

1
components/net/lwip/src/lwipopts.h
View File

@ -326,5 +326,6 @@
/* no read/write/close for socket */
#define LWIP_POSIX_SOCKETS_IO_NAMES 0
#define LWIP_NETIF_API 1
#endif /* __LWIPOPTS_H__ */

79
components/net/lwip/src/netif/ethernetif.c
View File

@ -87,55 +87,6 @@ static char eth_tx_thread_mb_pool[RT_LWIP_ETHTHREAD_MBOX_SIZE * 4];
static char eth_tx_thread_stack[RT_LWIP_ETHTHREAD_STACKSIZE];
#endif
/* the interface provided to LwIP */
err_t eth_init(struct netif *netif)
{
return ERR_OK;
}
err_t eth_input(struct pbuf *p, struct netif *inp)
{
struct eth_hdr *ethhdr;
if(p != RT_NULL)
{
#ifdef LINK_STATS
LINK_STATS_INC(link.recv);
#endif /* LINK_STATS */
ethhdr = p->payload;
switch(htons(ethhdr->type))
{
case ETHTYPE_IP:
etharp_ip_input(inp, p);
pbuf_header(p, -((rt_int16_t)sizeof(struct eth_hdr)));
if (tcpip_input(p, inp) != ERR_OK)
{
/* discard packet */
pbuf_free(p);
}
break;
case ETHTYPE_ARP:
etharp_arp_input(inp, (struct eth_addr *)inp->hwaddr, p);
break;
default:
pbuf_free(p);
p = RT_NULL;
break;
}
}
return ERR_OK;
}
err_t ethernetif_output(struct netif *netif, struct pbuf *p, struct ip_addr *ipaddr)
{
return etharp_output(netif, p, ipaddr);
}
err_t ethernetif_linkoutput(struct netif *netif, struct pbuf *p)
{
struct eth_tx_msg msg;
@ -184,27 +135,15 @@ rt_err_t eth_device_init(struct eth_device* dev, const char* name)
/* maximum transfer unit */
netif->mtu = ETHERNET_MTU;
/* broadcast capability */
netif->flags = NETIF_FLAG_BROADCAST;
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP;
/* get hardware address */
rt_device_control(&(dev->parent), NIOCTL_GADDR, netif->hwaddr);
/* set output */
netif->output = ethernetif_output;
netif->output = etharp_output;
netif->linkoutput = ethernetif_linkoutput;
/* add netif to lwip */
if (netif_add(netif, IP_ADDR_ANY, IP_ADDR_BROADCAST, IP_ADDR_ANY, dev,
eth_init, eth_input) == RT_NULL)
{
/* failed, unregister device and free netif */
rt_device_unregister(&(dev->parent));
rt_free(netif);
return -RT_ERROR;
}
netif_set_default(netif);
return RT_EOK;
}
@ -256,7 +195,12 @@ void eth_rx_thread_entry(void* parameter)
if (p != RT_NULL)
{
/* notify to upper layer */
eth_input(p, device->netif);
if( device->netif->input(p, device->netif) != ERR_OK )
{
LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: Input error\n"));
pbuf_free(p);
p = NULL;
}
}
else break;
}
@ -264,12 +208,17 @@ void eth_rx_thread_entry(void* parameter)
}
}
rt_err_t eth_device_ready(struct eth_device* dev)
rt_err_t eth_rx_ready(struct eth_device* dev)
{
/* post message to ethernet thread */
return rt_mb_send(&eth_rx_thread_mb, (rt_uint32_t)dev);
}
rt_err_t eth_device_ready(struct eth_device* dev)
{
return eth_rx_ready(dev);
}
rt_err_t eth_system_device_init()
{
rt_err_t result = RT_EOK;