/**
* Handle a IP address conflict after an ARP conflict detection
*/
static void
autoip_handle_arp_conflict(struct netif *netif)
{
/* Somehow detect if we are defending or retreating */
unsigned char defend = 1; /* tbd */
if(defend) {
if(netif->autoip->lastconflict > 0) {
/* retreat, there was a conflicting ARP in the last
* DEFEND_INTERVAL seconds
*/
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n"));
/* TODO: close all TCP sessions */
autoip_start(netif);
} else {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n"));
autoip_arp_announce(netif);
netif->autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND;
}
} else {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
("autoip_handle_arp_conflict(): we do not defend, retreating\n"));
/* TODO: close all TCP sessions */
autoip_start(netif);
}
}
/* -----------------------------------------------------------------------------
* When a cable is plugged in, this function is called
* ---------------------------------------------------------------------------*/
void uip_linkup() {
if (uip_xtcp_get_ifstate()){
uip_xtcp_down();
}
#if UIP_CONF_IPV4
if (uip_static_ip) {
uip_sethostaddr(&uip_static_ipconfig.ipaddr);
uip_setdraddr(&uip_static_ipconfig.gateway);
uip_setnetmask(&uip_static_ipconfig.netmask);
uip_xtcp_up();
} else {
dhcp_done = 0;
#if UIP_USE_DHCP
dhcpc_stop();
#endif
#if UIP_USE_AUTOIP
#if UIP_USE_DHCP
autoip_stop();
#else
autoip_start();
#endif
#endif
#if UIP_USE_DHCP
dhcpc_start();
#endif
}
#endif /* UIP_CONF_IPVx */
}
/**
* Handles every incoming ARP Packet, called by etharp_arp_input.
*
* @param netif network interface to use for autoip processing
* @param hdr Incoming ARP packet
*/
void
autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr)
{
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n"));
if ((netif->autoip != NULL) && (netif->autoip->state != AUTOIP_STATE_OFF)) {
/* when ip.src == llipaddr && hw.src != netif->hwaddr
*
* when probing ip.dst == llipaddr && hw.src != netif->hwaddr
* we have a conflict and must solve it
*/
struct ip_addr sipaddr, dipaddr;
struct eth_addr netifaddr;
netifaddr.addr[0] = netif->hwaddr[0];
netifaddr.addr[1] = netif->hwaddr[1];
netifaddr.addr[2] = netif->hwaddr[2];
netifaddr.addr[3] = netif->hwaddr[3];
netifaddr.addr[4] = netif->hwaddr[4];
netifaddr.addr[5] = netif->hwaddr[5];
/* Copy struct ip_addr2 to aligned ip_addr, to support compilers without
* structure packing (not using structure copy which breaks strict-aliasing rules).
*/
SMEMCPY(&sipaddr, &hdr->sipaddr, sizeof(sipaddr));
SMEMCPY(&dipaddr, &hdr->dipaddr, sizeof(dipaddr));
if ((netif->autoip->state == AUTOIP_STATE_PROBING) ||
((netif->autoip->state == AUTOIP_STATE_ANNOUNCING) &&
(netif->autoip->sent_num == 0))) {
/* RFC 3927 Section 2.2.1:
* from beginning to after ANNOUNCE_WAIT
* seconds we have a conflict if
* ip.src == llipaddr OR
* ip.dst == llipaddr && hw.src != own hwaddr
*/
if ((ip_addr_cmp(&sipaddr, &netif->autoip->llipaddr)) ||
(ip_addr_cmp(&dipaddr, &netif->autoip->llipaddr) &&
!eth_addr_cmp(&netifaddr, &hdr->shwaddr))) {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
("autoip_arp_reply(): Probe Conflict detected\n"));
autoip_start(netif);
}
} else {
/* RFC 3927 Section 2.5:
* in any state we have a conflict if
* ip.src == llipaddr && hw.src != own hwaddr
*/
if (ip_addr_cmp(&sipaddr, &netif->autoip->llipaddr) &&
!eth_addr_cmp(&netifaddr, &hdr->shwaddr)) {
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
("autoip_arp_reply(): Conflicting ARP-Packet detected\n"));
autoip_handle_arp_conflict(netif);
}
}
}
}
void uip_linkup() {
if (get_uip_xtcp_ifstate())
uip_xtcp_down();
if (uip_static_ip) {
#if UIP_CONF_IPV6
uip_ipaddr_t ipaddr;
uip_ipaddr(ipaddr,
uip_static_ipconfig.ipaddr[0],
uip_static_ipconfig.ipaddr[1],
uip_static_ipconfig.ipaddr[2],
uip_static_ipconfig.ipaddr[3]);
uip_sethostaddr(ipaddr);
uip_ipaddr(ipaddr,
uip_static_ipconfig.gateway[0],
uip_static_ipconfig.gateway[1],
uip_static_ipconfig.gateway[2],
uip_static_ipconfig.gateway[3]);
uip_setdraddr(ipaddr);
uip_ipaddr(ipaddr,
uip_static_ipconfig.netmask[0],
uip_static_ipconfig.netmask[1],
uip_static_ipconfig.netmask[2],
uip_static_ipconfig.netmask[3]);
uip_setnetmask(ipaddr);
uip_setsubnetaddr();
#else
uip_sethostaddr(uip_static_ipconfig.ipaddr);
uip_setdraddr(uip_static_ipconfig.gateway);
uip_setnetmask(uip_static_ipconfig.netmask);
uip_setsubnetaddr();
#endif
uip_xtcp_up();
} else {
dhcp_done = 0;
#if UIP_USE_DHCP
dhcpc_stop();
#endif
#if UIP_USE_AUTOIP
#if UIP_USE_DHCP
autoip_stop();
#else
autoip_start();
#endif
#endif
#if UIP_USE_DHCP
dhcpc_start();
#endif
}
}
/* Init lwIP TCP/IP stack */
void init_lwip_stack (unsigned int IPaddress, unsigned int NETmask, unsigned int GATEaddress, unsigned char EnDHCP, unsigned char EnAutoIP)
{
struct ip_addr ip_addr, net_mask, gate_addr;
/* Initialize all lwIP modules */
lwip_init ();
/* Setup static IP values */
ip_addr.addr = htonl(IPaddress);
net_mask.addr = htonl(NETmask);
gate_addr.addr = htonl(GATEaddress);
#if (LWIP_AUTOIP || LWIP_DHCP)
/* If DHCP or AutoIP is enabled clear IP values */
if (EnDHCP || EnAutoIP) {
ip_addr.addr = 0;
net_mask.addr = 0;
gate_addr.addr = 0;
}
#endif
/* Add a network interface to the list of lwIP netifs */
/* use ethernet_input() insted of tcpip_input() */
netif_add(&enc28j60_netif, &ip_addr, &net_mask, &gate_addr, NULL, ethernetif_init, ip_input);
/* Set a 'enc28j60_netif' interface as the default network interface */
netif_set_default(&enc28j60_netif);
#if LWIP_DHCP
/* Start DHCP if it enabled */
if (EnDHCP)
dhcp_start (&enc28j60_netif);
#endif
#if LWIP_AUTOIP
/* Start AutoIP if it enabled */
if (EnAutoIP)
autoip_start (&enc28j60_netif);
#endif
/* Bring an interface up, available for processing traffic */
netif_set_up (&enc28j60_netif);
}
/**
* @brief Starts the interface in Lwip according to its mode.
*
* @param lwipIf The addresses and modes to set.
* @param ifNum The interface to set.
*
* @return True if mode ok, false otherwise.
*/
static bool netifStart(LWIP_IF* const lwipIf, const unsigned int ifNum)
{
bool ret = true;
switch(lwipIf->ipMode)
{
case IPADDR_USE_DHCP:
ret = lwIPDHCPComplete(ifNum);
break;
case IPADDR_USE_AUTOIP:
autoip_start(&cpswNetIF[ifNum]);
/*This has no break on purpose, since both autoip and static must do netif_set_up*/
case IPADDR_USE_STATIC:
netif_set_up(&cpswNetIF[ifNum]);
break;
default:
ret = false;
}
return ret;
}
/*..........................................................................*/
struct netif *eth_driver_init(QActive *active,
enum_t base_sig,
u8_t macaddr[NETIF_MAX_HWADDR_LEN])
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
lwip_init(); /* nitialize the lwIP stack */
/* set MAC address in the network interface... */
l_netif.hwaddr_len = NETIF_MAX_HWADDR_LEN;
memcpy(&l_netif.hwaddr[0], macaddr, NETIF_MAX_HWADDR_LEN);
l_active = active; /*save the active object associated with this driver */
/* set up the static events issed by this driver... */
l_lwipEvt[LWIP_RX_READY_OFFSET] .sig = base_sig + LWIP_RX_READY_OFFSET;
l_lwipEvt[LWIP_TX_READY_OFFSET] .sig = base_sig + LWIP_TX_READY_OFFSET;
l_lwipEvt[LWIP_RX_OVERRUN_OFFSET].sig = base_sig + LWIP_RX_OVERRUN_OFFSET;
#if LWIP_NETIF_HOSTNAME
l_netif.hostname = "lwIP"; /* initialize interface hostname */
#endif
l_netif.name[0] = 'Q';
l_netif.name[1] = 'P';
/*
* Initialize the snmp variables and counters inside the struct netif.
* The last argument should be replaced with your link speed, in units
* of bits per second.
*/
NETIF_INIT_SNMP(&l_netif, snmp_ifType_ethernet_csmacd, 1000000);
/* We directly use etharp_output() here to save a function call.
* You can instead declare your own function an call etharp_output()
* from it if you have to do some checks before sending (e.g. if link
* is available...) */
l_netif.output = ðarp_output;
l_netif.linkoutput = ðernetif_output;
#if (LWIP_DHCP == 0) && (LWIP_AUTOIP == 0)
/* No mechanism of obtaining IP address specified, use static IP: */
IP4_ADDR(&ipaddr, STATIC_IPADDR0, STATIC_IPADDR1,
STATIC_IPADDR2, STATIC_IPADDR3);
IP4_ADDR(&netmask, STATIC_NET_MASK0, STATIC_NET_MASK1,
STATIC_NET_MASK2, STATIC_NET_MASK3);
IP4_ADDR(&gwaddr, STATIC_GW_IPADDR0, STATIC_GW_IPADDR1,
STATIC_GW_IPADDR2, STATIC_GW_IPADDR3);
#else
/* either DHCP or AUTOIP are configured, start with zero IP addresses: */
IP4_ADDR(&ipaddr, 0, 0, 0, 0);
IP4_ADDR(&netmask, 0, 0, 0, 0);
IP4_ADDR(&gw, 0, 0, 0, 0);
#endif
/* add and configure the Ethernet interface with default settings */
netif_add(&l_netif,
&ipaddr, &netmask, &gw, /* configured IP addresses */
active, /* use this active object as the state */
ðernetif_init, /* Ethernet interface initialization */
&ip_input); /* standard IP input processing */
netif_set_default(&l_netif);
netif_set_up(&l_netif); /* bring the interface up */
#if (LWIP_DHCP != 0)
dhcp_start(&l_netif); /* start DHCP if configured in lwipopts.h */
/* NOTE: If LWIP_AUTOIP is configured in lwipopts.h and
* LWIP_DHCP_AUTOIP_COOP is set as well, the DHCP process will start
* AutoIP after DHCP fails for 59 seconds.
*/
#elif (LWIP_AUTOIP != 0)
autoip_start(&l_netif); /* start AutoIP if configured in lwipopts.h */
#endif
/* Enable Ethernet TX and RX Packet Interrupts. */
ETH->IM |= (ETH_INT_RX | ETH_INT_TX);
#if LINK_STATS
ETH->IM |= ETH_INT_RXOF;
#endif
QS_OBJ_DICTIONARY(&l_Ethernet_IRQHandler);
return &l_netif;
}
/* This function initializes all network interfaces */
static void
msvc_netif_init()
{
#if USE_ETHERNET
ip_addr_t ipaddr, netmask, gw;
#endif /* USE_ETHERNET */
#if PPP_SUPPORT
const char *username = NULL, *password = NULL;
#ifdef PPP_USERNAME
username = PPP_USERNAME;
#endif
#ifdef PPP_PASSWORD
password = PPP_PASSWORD;
#endif
printf("pppInit\n");
pppInit();
pppSetAuth(PPPAUTHTYPE_ANY, username, password);
printf("pppOpen: COM%d\n", (int)sio_idx);
#if PPPOS_SUPPORT
ppp_sio = sio_open(sio_idx);
if (ppp_sio == NULL) {
printf("sio_open error\n");
} else {
ppp_desc = pppOpen(ppp_sio, pppLinkStatusCallback, NULL);
}
#endif /* PPPOS_SUPPORT */
#endif /* PPP_SUPPORT */
#if USE_ETHERNET
ip_addr_set_zero(&gw);
ip_addr_set_zero(&ipaddr);
ip_addr_set_zero(&netmask);
#if USE_ETHERNET_TCPIP
#if USE_DHCP
printf("Starting lwIP, local interface IP is dhcp-enabled\n");
#elif USE_AUTOIP
printf("Starting lwIP, local interface IP is autoip-enabled\n");
#else /* USE_DHCP */
LWIP_PORT_INIT_GW(&gw);
LWIP_PORT_INIT_IPADDR(&ipaddr);
LWIP_PORT_INIT_NETMASK(&netmask);
printf("Starting lwIP, local interface IP is %s\n", ip_ntoa(&ipaddr));
#endif /* USE_DHCP */
#endif /* USE_ETHERNET_TCPIP */
#if NO_SYS
#if LWIP_ARP
netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, pcapif_init, ethernet_input));
#else /* LWIP_ARP */
netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, pcapif_init, ip_input));
#endif /* LWIP_ARP */
#else /* NO_SYS */
netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, pcapif_init, tcpip_input));
#if LWIP_IPV6
netif_create_ip6_linklocal_address(&netif, 1);
printf("ip6 linklocal address: ");
ip6_addr_debug_print(0xFFFFFFFF & ~LWIP_DBG_HALT, &netif.ip6_addr[0]);
printf("\n");
#endif /* LWIP_IPV6 */
#endif /* NO_SYS */
#if LWIP_NETIF_STATUS_CALLBACK
netif_set_status_callback(&netif, status_callback);
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif_set_link_callback(&netif, link_callback);
#endif /* LWIP_NETIF_LINK_CALLBACK */
#if USE_ETHERNET_TCPIP
#if LWIP_AUTOIP
autoip_set_struct(&netif, &netif_autoip);
#endif /* LWIP_AUTOIP */
#if LWIP_DHCP
dhcp_set_struct(&netif, &netif_dhcp);
#endif /* LWIP_DHCP */
#if USE_DHCP
dhcp_start(&netif);
#elif USE_AUTOIP
autoip_start(&netif);
#else /* USE_DHCP */
netif_set_up(&netif);
#endif /* USE_DHCP */
#else /* USE_ETHERNET_TCPIP */
/* Use ethernet for PPPoE only */
netif.flags &= ~(NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP); /* no ARP */
netif.flags |= NETIF_FLAG_ETHERNET; /* but pure ethernet */
#endif /* USE_ETHERNET_TCPIP */
#if PPP_SUPPORT && PPPOE_SUPPORT
/* start PPPoE after ethernet netif is added! */
ppp_desc = pppOverEthernetOpen(&netif, NULL, NULL, pppLinkStatusCallback, NULL);
#endif /* PPP_SUPPORT && PPPOE_SUPPORT */
#endif /* USE_ETHERNET */
}
//*****************************************************************************
//
// Completes the network configuration change. This is directly called when
// not using a RTOS and provided as a callback to the TCP/IP thread when using
// a RTOS.
//
//*****************************************************************************
static void
lwIPPrivateNetworkConfigChange(void *pvArg)
{
unsigned long ulIPMode;
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
//
// Get the new address mode.
//
ulIPMode = (unsigned long)pvArg;
//
// Setup the network address values.
//
if(ulIPMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(g_ulIPAddr);
net_mask.addr = htonl(g_ulNetMask);
gw_addr.addr = htonl(g_ulGWAddr);
}
#if LWIP_DHCP || LWIP_AUTOIP
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
#endif
//
// Switch on the current IP Address Aquisition mode.
//
switch(g_ulIPMode)
{
//
// Static IP
//
case IPADDR_USE_STATIC:
{
//
// Set the new address parameters. This will change the address
// configuration in lwIP, and if necessary, will reset any links
// that are active. This is valid for all three modes.
//
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
//
// If we are going to DHCP mode, then start the DHCP server now.
//
#if LWIP_DHCP
if(ulIPMode == IPADDR_USE_DHCP)
{
dhcp_start(&g_sNetIF);
}
#endif
//
// If we are going to AutoIP mode, then start the AutoIP process
// now.
//
#if LWIP_AUTOIP
if(ulIPMode == IPADDR_USE_AUTOIP)
{
autoip_start(&g_sNetIF);
}
#endif
//
// And we're done.
//
break;
}
//
// DHCP (with AutoIP fallback).
//
#if LWIP_DHCP
case IPADDR_USE_DHCP:
{
//
// If we are going to static IP addressing, then disable DHCP and
// force the new static IP address.
//
if(ulIPMode == IPADDR_USE_STATIC)
{
dhcp_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
}
//
// If we are going to AUTO IP addressing, then disable DHCP, set
// the default addresses, and start AutoIP.
//
#if LWIP_AUTOIP
else if(ulIPMode == IPADDR_USE_AUTOIP)
{
dhcp_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
autoip_start(&g_sNetIF);
}
#endif
break;
}
#endif
//
// AUTOIP
//
#if LWIP_AUTOIP
case IPADDR_USE_AUTOIP:
{
//
// If we are going to static IP addressing, then disable AutoIP and
// force the new static IP address.
//
if(ulIPMode == IPADDR_USE_STATIC)
{
autoip_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
}
//
// If we are going to DHCP addressing, then disable AutoIP, set the
// default addresses, and start dhcp.
//
#if LWIP_DHCP
else if(ulIPMode == IPADDR_USE_DHCP)
{
autoip_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
dhcp_start(&g_sNetIF);
}
#endif
break;
}
#endif
}
//
// Save the new mode.
//
g_ulIPMode = ulIPMode;
}
//*****************************************************************************
//
// Completes the initialization of lwIP. This is directly called when not
// using a RTOS and provided as a callback to the TCP/IP thread when using a
// RTOS.
//
//*****************************************************************************
static void
lwIPPrivateInit(void *pvArg)
{
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
//
// If not using a RTOS, initialize the lwIP stack.
//
#if NO_SYS
lwip_init();
#endif
//
// If using a RTOS, create a queue (to be used as a semaphore) to signal
// the Ethernet interrupt task from the Ethernet interrupt handler.
//
#if !NO_SYS
xQueueCreate(g_pcQueueMem, sizeof(g_pcQueueMem), 1, sizeof(void *),
&g_pInterrupt);
#endif
//
// If using a RTOS, create the Ethernet interrupt task.
//
#if !NO_SYS
xTaskCreate(lwIPInterruptTask, (signed portCHAR *)"eth_int",
(signed portCHAR *)g_pulStack, sizeof(g_pulStack), 0, 1, 0);
#endif
//
// Setup the network address values.
//
if(g_ulIPMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(g_ulIPAddr);
net_mask.addr = htonl(g_ulNetMask);
gw_addr.addr = htonl(g_ulGWAddr);
}
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
//
// Create, configure and add the Ethernet controller interface with
// default settings. ip_input should be used to send packets directly to
// the stack when not using a RTOS and tcpip_input should be used to send
// packets to the TCP/IP thread's queue when using a RTOS.
//
#if NO_SYS
netif_add(&g_sNetIF, &ip_addr, &net_mask, &gw_addr, NULL, stellarisif_init,
ip_input);
#else
netif_add(&g_sNetIF, &ip_addr, &net_mask, &gw_addr, NULL, stellarisif_init,
tcpip_input);
#endif
netif_set_default(&g_sNetIF);
//
// Start DHCP, if enabled.
//
#if LWIP_DHCP
if(g_ulIPMode == IPADDR_USE_DHCP)
{
dhcp_start(&g_sNetIF);
}
#endif
//
// Start AutoIP, if enabled and DHCP is not.
//
#if LWIP_AUTOIP
if(g_ulIPMode == IPADDR_USE_AUTOIP)
{
autoip_start(&g_sNetIF);
}
#endif
//
// Bring the interface up.
//
netif_set_up(&g_sNetIF);
//
// Setup a timeout for the host timer callback function if using a RTOS.
//
#if !NO_SYS && HOST_TMR_INTERVAL
sys_timeout(HOST_TMR_INTERVAL, lwIPPrivateHostTimer, NULL);
#endif
//
// If not running on a Fury-class device, then MDIX is handled in software.
// In this case, when using a RTOS, setup a timeout for the soft-MDIX
// handler.
//
#if !NO_SYS
if(!CLASS_IS_FURY)
{
sys_timeout(SOFT_MDIX_INTERVAL, lwIPSoftMDIXTimer, NULL);
}
#endif
}
/**
*
* \brief Initializes the lwIP TCP/IP stack.
*
* \param lwipIf The interface structure for lwIP
*
* \return IP Address.
*/
unsigned int lwIPInit(LWIP_IF *lwipIf,char *hwOK)
{
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
unsigned int *ipAddrPtr;
static unsigned int lwipInitFlag = 0;
unsigned int ifNum;
unsigned int temp;
/* do lwip library init only once */
if(0 == lwipInitFlag)
{
lwip_init();
}
/* Setup the network address values. */
if(lwipIf->ipMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(lwipIf->ipAddr);
net_mask.addr = htonl(lwipIf->netMask);
gw_addr.addr = htonl(lwipIf->gwAddr);
}
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
#ifdef CPSW_DUAL_MAC_MODE
ifNum = (lwipIf->instNum * MAX_SLAVEPORT_PER_INST) + lwipIf->slvPortNum - 1;
#else
ifNum = lwipIf->instNum;
#endif
cpswPortIf[ifNum].inst_num = lwipIf->instNum;
cpswPortIf[ifNum].port_num = lwipIf->slvPortNum;
/* set MAC hardware address */
for(temp = 0; temp < LEN_MAC_ADDRESS; temp++)
{
cpswPortIf[ifNum].eth_addr[temp] =
lwipIf->macArray[(LEN_MAC_ADDRESS - 1) - temp];
}
/*
** Create, configure and add the Ethernet controller interface with
** default settings. ip_input should be used to send packets directly to
** the stack. The lwIP will internaly call the cpswif_init function.
*/
if(NULL ==
netif_add(&cpswNetIF[ifNum], &ip_addr, &net_mask, &gw_addr,
&cpswPortIf[ifNum], cpswif_init, ip_input,hwOK))
{
LWIP_PRINTF("\n\rUnable to add interface for interface %d", ifNum);
return 0;
}
if(0 == lwipInitFlag)
{
netif_set_default(&cpswNetIF[ifNum]);
lwipInitFlag = 1;
}
/* Start DHCP, if enabled. */
#if LWIP_DHCP
if(lwipIf->ipMode == IPADDR_USE_DHCP)
{
lwIPDHCPComplete(ifNum);
}
#endif
/* Start AutoIP, if enabled and DHCP is not. */
#if LWIP_AUTOIP
if(lwipIf->ipMode == IPADDR_USE_AUTOIP)
{
autoip_start(&cpswNetIF[ifNum]);
}
#endif
if((lwipIf->ipMode == IPADDR_USE_STATIC)
||(lwipIf->ipMode == IPADDR_USE_AUTOIP))
{
/* Bring the interface up */
netif_set_up(&cpswNetIF[ifNum]);
}
ipAddrPtr = (unsigned int*)&(cpswNetIF[ifNum].ip_addr);
return (*ipAddrPtr);
}
/* This function initializes all network interfaces */
static void
msvc_netif_init()
{
#if USE_ETHERNET
ip_addr_t ipaddr, netmask, gw;
#endif /* USE_ETHERNET */
#if USE_SLIPIF
u8_t num_slip1 = 0;
ip_addr_t ipaddr_slip1, netmask_slip1, gw_slip1;
#if USE_SLIPIF > 1
u8_t num_slip2 = 1;
ip_addr_t ipaddr_slip2, netmask_slip2, gw_slip2;
#endif /* USE_SLIPIF > 1 */
#endif /* USE_SLIPIF */
#if PPP_SUPPORT
const char *username = NULL, *password = NULL;
#ifdef PPP_USERNAME
username = PPP_USERNAME;
#endif
#ifdef PPP_PASSWORD
password = PPP_PASSWORD;
#endif
printf("pppInit\n");
pppInit();
pppSetAuth(PPPAUTHTYPE_ANY, username, password);
printf("pppOpen: COM%d\n", (int)sio_idx);
#if PPPOS_SUPPORT
ppp_sio = sio_open(sio_idx);
if (ppp_sio == NULL) {
printf("sio_open error\n");
} else {
ppp_desc = pppOpen(ppp_sio, pppLinkStatusCallback, NULL);
}
#endif /* PPPOS_SUPPORT */
#endif /* PPP_SUPPORT */
#if USE_ETHERNET
ip_addr_set_zero(&gw);
ip_addr_set_zero(&ipaddr);
ip_addr_set_zero(&netmask);
#if USE_ETHERNET_TCPIP
#if USE_DHCP
printf("Starting lwIP, local interface IP is dhcp-enabled\n");
#elif USE_AUTOIP
printf("Starting lwIP, local interface IP is autoip-enabled\n");
#else /* USE_DHCP */
LWIP_PORT_INIT_GW(&gw);
LWIP_PORT_INIT_IPADDR(&ipaddr);
LWIP_PORT_INIT_NETMASK(&netmask);
printf("Starting lwIP, local interface IP is %s\n", ip_ntoa(&ipaddr));
#endif /* USE_DHCP */
#endif /* USE_ETHERNET_TCPIP */
#if NO_SYS
#if LWIP_ARP
netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, pcapif_init, ethernet_input));
#else /* LWIP_ARP */
netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, pcapif_init, ip_input));
#endif /* LWIP_ARP */
#else /* NO_SYS */
netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gw, NULL, pcapif_init, tcpip_input));
#endif /* NO_SYS */
#if LWIP_NETIF_STATUS_CALLBACK
netif_set_status_callback(&netif, status_callback);
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif_set_link_callback(&netif, link_callback);
#endif /* LWIP_NETIF_LINK_CALLBACK */
#if USE_ETHERNET_TCPIP
#if LWIP_AUTOIP
autoip_set_struct(&netif, &netif_autoip);
#endif /* LWIP_AUTOIP */
#if LWIP_DHCP
dhcp_set_struct(&netif, &netif_dhcp);
#endif /* LWIP_DHCP */
#if USE_DHCP
dhcp_start(&netif);
#elif USE_AUTOIP
autoip_start(&netif);
#else /* USE_DHCP */
netif_set_up(&netif);
#endif /* USE_DHCP */
#else /* USE_ETHERNET_TCPIP */
/* Use ethernet for PPPoE only */
netif.flags &= ~(NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP); /* no ARP */
netif.flags |= NETIF_FLAG_ETHERNET; /* but pure ethernet */
#endif /* USE_ETHERNET_TCPIP */
#if PPP_SUPPORT && PPPOE_SUPPORT
/* start PPPoE after ethernet netif is added! */
ppp_desc = pppOverEthernetOpen(&netif, NULL, NULL, pppLinkStatusCallback, NULL);
#endif /* PPP_SUPPORT && PPPOE_SUPPORT */
#endif /* USE_ETHERNET */
#if USE_SLIPIF
LWIP_PORT_INIT_SLIP1_IPADDR(&ipaddr_slip1);
LWIP_PORT_INIT_SLIP1_GW(&gw_slip1);
LWIP_PORT_INIT_SLIP1_NETMASK(&netmask_slip1);
printf("Starting lwIP slipif, local interface IP is %s\n", ip_ntoa(&ipaddr_slip1));
#if SIO_USE_COMPORT
num_slip1++; /* COM ports cannot be 0-based */
#endif
netif_add(&slipif1, &ipaddr_slip1, &netmask_slip1, &gw_slip1, &num_slip1, slipif_init, ip_input);
#if !USE_ETHERNET
netif_set_default(&slipif1);
#endif /* !USE_ETHERNET */
#if LWIP_NETIF_STATUS_CALLBACK
netif_set_status_callback(&slipif1, status_callback);
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif_set_link_callback(&slipif1, link_callback);
#endif /* LWIP_NETIF_LINK_CALLBACK */
netif_set_up(&slipif1);
#if USE_SLIPIF > 1
LWIP_PORT_INIT_SLIP2_IPADDR(&ipaddr_slip2);
LWIP_PORT_INIT_SLIP2_GW(&gw_slip2);
LWIP_PORT_INIT_SLIP2_NETMASK(&netmask_slip2);
printf("Starting lwIP SLIP if #2, local interface IP is %s\n", ip_ntoa(&ipaddr_slip2));
#if SIO_USE_COMPORT
num_slip2++; /* COM ports cannot be 0-based */
#endif
netif_add(&slipif2, &ipaddr_slip2, &netmask_slip2, &gw_slip2, &num_slip2, slipif_init, ip_input);
#if LWIP_NETIF_STATUS_CALLBACK
netif_set_status_callback(&slipif2, status_callback);
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif_set_link_callback(&slipif2, link_callback);
#endif /* LWIP_NETIF_LINK_CALLBACK */
netif_set_up(&slipif2);
#endif /* USE_SLIPIF > 1*/
#endif /* USE_SLIPIF */
}
/* This function initializes all network interfaces */
static void
msvc_netif_init(void)
{
#if LWIP_IPV4 && USE_ETHERNET
ip4_addr_t ipaddr, netmask, gw;
#endif /* LWIP_IPV4 && USE_ETHERNET */
#if USE_SLIPIF
u8_t num_slip1 = 0;
#if LWIP_IPV4
ip4_addr_t ipaddr_slip1, netmask_slip1, gw_slip1;
#endif
#if USE_SLIPIF > 1
u8_t num_slip2 = 1;
#if LWIP_IPV4
ip4_addr_t ipaddr_slip2, netmask_slip2, gw_slip2;
#endif
#endif /* USE_SLIPIF > 1 */
#endif /* USE_SLIPIF */
#if USE_DHCP || USE_AUTOIP
err_t err;
#endif
#if USE_PPP
const char *username = NULL, *password = NULL;
#ifdef PPP_USERNAME
username = PPP_USERNAME;
#endif
#ifdef PPP_PASSWORD
password = PPP_PASSWORD;
#endif
printf("ppp_connect: COM%d\n", (int)sio_idx);
#if PPPOS_SUPPORT
ppp_sio = sio_open(sio_idx);
if (ppp_sio == NULL) {
printf("sio_open error\n");
} else {
ppp = pppos_create(&ppp_netif, ppp_output_cb, pppLinkStatusCallback, NULL);
if (ppp == NULL) {
printf("pppos_create error\n");
} else {
ppp_set_auth(ppp, PPPAUTHTYPE_ANY, username, password);
ppp_connect(ppp, 0);
}
}
#endif /* PPPOS_SUPPORT */
#endif /* USE_PPP */
#if USE_ETHERNET
#if LWIP_IPV4
#define NETIF_ADDRS &ipaddr, &netmask, &gw,
ip4_addr_set_zero(&gw);
ip4_addr_set_zero(&ipaddr);
ip4_addr_set_zero(&netmask);
#if USE_ETHERNET_TCPIP
#if USE_DHCP
printf("Starting lwIP, local interface IP is dhcp-enabled\n");
#elif USE_AUTOIP
printf("Starting lwIP, local interface IP is autoip-enabled\n");
#else /* USE_DHCP */
LWIP_PORT_INIT_GW(&gw);
LWIP_PORT_INIT_IPADDR(&ipaddr);
LWIP_PORT_INIT_NETMASK(&netmask);
printf("Starting lwIP, local interface IP is %s\n", ip4addr_ntoa(&ipaddr));
#endif /* USE_DHCP */
#endif /* USE_ETHERNET_TCPIP */
#else /* LWIP_IPV4 */
#define NETIF_ADDRS
printf("Starting lwIP, IPv4 disable\n");
#endif /* LWIP_IPV4 */
#if NO_SYS
netif_set_default(netif_add(&netif, NETIF_ADDRS NULL, pcapif_init, netif_input));
#else /* NO_SYS */
netif_set_default(netif_add(&netif, NETIF_ADDRS NULL, pcapif_init, tcpip_input));
#endif /* NO_SYS */
#if LWIP_IPV6
netif_create_ip6_linklocal_address(&netif, 1);
printf("ip6 linklocal address: ");
ip6_addr_debug_print(0xFFFFFFFF & ~LWIP_DBG_HALT, netif_ip6_addr(&netif, 0));
printf("\n");
#endif /* LWIP_IPV6 */
#if LWIP_NETIF_STATUS_CALLBACK
netif_set_status_callback(&netif, status_callback);
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif_set_link_callback(&netif, link_callback);
#endif /* LWIP_NETIF_LINK_CALLBACK */
#if USE_ETHERNET_TCPIP
#if LWIP_AUTOIP
autoip_set_struct(&netif, &netif_autoip);
#endif /* LWIP_AUTOIP */
#if LWIP_DHCP
dhcp_set_struct(&netif, &netif_dhcp);
#endif /* LWIP_DHCP */
netif_set_up(&netif);
#if USE_DHCP
err = dhcp_start(&netif);
LWIP_ASSERT("dhcp_start failed", err == ERR_OK);
#elif USE_AUTOIP
err = autoip_start(&netif);
LWIP_ASSERT("autoip_start failed", err == ERR_OK);
#endif /* USE_DHCP */
#else /* USE_ETHERNET_TCPIP */
/* Use ethernet for PPPoE only */
netif.flags &= ~(NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP); /* no ARP */
netif.flags |= NETIF_FLAG_ETHERNET; /* but pure ethernet */
#endif /* USE_ETHERNET_TCPIP */
#if USE_PPP && PPPOE_SUPPORT
/* start PPPoE after ethernet netif is added! */
ppp = pppoe_create(&ppp_netif, &netif, NULL, NULL, pppLinkStatusCallback, NULL);
if (ppp == NULL) {
printf("pppos_create error\n");
} else {
ppp_set_auth(ppp, PPPAUTHTYPE_ANY, username, password);
ppp_connect(ppp, 0);
}
#endif /* USE_PPP && PPPOE_SUPPORT */
#endif /* USE_ETHERNET */
#if USE_SLIPIF
#if LWIP_IPV4
#define SLIP1_ADDRS &ipaddr_slip1, &netmask_slip1, &gw_slip1,
LWIP_PORT_INIT_SLIP1_IPADDR(&ipaddr_slip1);
LWIP_PORT_INIT_SLIP1_GW(&gw_slip1);
LWIP_PORT_INIT_SLIP1_NETMASK(&netmask_slip1);
printf("Starting lwIP slipif, local interface IP is %s\n", ip4addr_ntoa(&ipaddr_slip1));
#else
#define SLIP1_ADDRS
printf("Starting lwIP slipif\n");
#endif
#if defined(SIO_USE_COMPORT) && SIO_USE_COMPORT
num_slip1++; /* COM ports cannot be 0-based */
#endif
netif_add(&slipif1, SLIP1_ADDRS &num_slip1, slipif_init, ip_input);
#if !USE_ETHERNET
netif_set_default(&slipif1);
#endif /* !USE_ETHERNET */
#if LWIP_IPV6
netif_create_ip6_linklocal_address(&slipif1, 1);
printf("SLIP ip6 linklocal address: ");
ip6_addr_debug_print(0xFFFFFFFF & ~LWIP_DBG_HALT, netif_ip6_addr(&slipif1, 0));
printf("\n");
#endif /* LWIP_IPV6 */
#if LWIP_NETIF_STATUS_CALLBACK
netif_set_status_callback(&slipif1, status_callback);
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif_set_link_callback(&slipif1, link_callback);
#endif /* LWIP_NETIF_LINK_CALLBACK */
netif_set_up(&slipif1);
#if USE_SLIPIF > 1
#if LWIP_IPV4
#define SLIP2_ADDRS &ipaddr_slip2, &netmask_slip2, &gw_slip2,
LWIP_PORT_INIT_SLIP2_IPADDR(&ipaddr_slip2);
LWIP_PORT_INIT_SLIP2_GW(&gw_slip2);
LWIP_PORT_INIT_SLIP2_NETMASK(&netmask_slip2);
printf("Starting lwIP SLIP if #2, local interface IP is %s\n", ip4addr_ntoa(&ipaddr_slip2));
#else
#define SLIP2_ADDRS
printf("Starting lwIP SLIP if #2\n");
#endif
#if defined(SIO_USE_COMPORT) && SIO_USE_COMPORT
num_slip2++; /* COM ports cannot be 0-based */
#endif
netif_add(&slipif2, SLIP2_ADDRS &num_slip2, slipif_init, ip_input);
#if LWIP_IPV6
netif_create_ip6_linklocal_address(&slipif1, 1);
printf("SLIP2 ip6 linklocal address: ");
ip6_addr_debug_print(0xFFFFFFFF & ~LWIP_DBG_HALT, netif_ip6_addr(&slipif2, 0));
printf("\n");
#endif /* LWIP_IPV6 */
#if LWIP_NETIF_STATUS_CALLBACK
netif_set_status_callback(&slipif2, status_callback);
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif_set_link_callback(&slipif2, link_callback);
#endif /* LWIP_NETIF_LINK_CALLBACK */
netif_set_up(&slipif2);
#endif /* USE_SLIPIF > 1*/
#endif /* USE_SLIPIF */
}
//*****************************************************************************
//
//! Change the configuration of the lwIP network interface.
//!
//! \param ulIPAddr is the new IP address to be used (static).
//! \param ulNetMask is the new network mask to be used (static).
//! \param ulGWAddr is the new Gateway address to be used (static).
//! \param ulIPMode is the IP Address Mode. \b IPADDR_USE_STATIC 0 will force
//! static IP addressing to be used, \b IPADDR_USE_DHCP will force DHCP with
//! fallback to Link Local (Auto IP), while \b IPADDR_USE_AUTOIP will force
//! Link Local only.
//!
//! This function will evaluate the new configuration data. If necessary, the
//! interface will be brought down, reconfigured, and then brought back up
//! with the new configuration.
//!
//! \return None.
//
//*****************************************************************************
void lwIPNetworkConfigChange(struct netif *netif, IP_CONFIG * ipCfg)
{
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
IP_CONFIG currentIPConfig;
// Check the parameters.
#if LWIP_DHCP && LWIP_AUTOIP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_DHCP) ||
(ipCfg->IPMode == IPADDR_USE_AUTOIP))
#elif LWIP_DHCP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_DHCP))
#elif LWIP_AUTOIP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_AUTOIP))
#else
ASSERT(ipCfg->IPMode == IPADDR_USE_STATIC)
#endif
// Setup the network address values.
if (ipCfg->IPMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(ipCfg->IPAddr);
net_mask.addr = htonl(ipCfg->NetMask);
gw_addr.addr = htonl(ipCfg->GWAddr);
}
#if LWIP_DHCP || LWIP_AUTOIP
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
#endif
// Switch on the current IP Address Aquisition mode.
currentIPConfig.IPMode = IPADDR_USE_DHCP;
LWIPServiceTaskIPConfigGet(netif, ¤tIPConfig);
switch (currentIPConfig.IPMode)
{
// Static IP
case IPADDR_USE_STATIC:
{
// Set the new address parameters. This will change the address
// configuration in lwIP, and if necessary, will reset any links
// that are active. This is valid for all three modes.
//
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
// If we are going to DHCP mode, then start the DHCP server now.
#if LWIP_DHCP
if (ipCfg->IPMode == IPADDR_USE_DHCP)
{
dhcp_start(netif);
}
#endif
// If we are going to AutoIP mode, then start the AutoIP process
// now.
#if LWIP_AUTOIP
if (ipCfg->IPMode == IPADDR_USE_AUTOIP)
{
autoip_start(netif);
}
#endif
// And we're done.
break;
}
// DHCP (with AutoIP fallback).
#if LWIP_DHCP
case IPADDR_USE_DHCP:
{
//
// If we are going to static IP addressing, then disable DHCP and
// force the new static IP address.
//
if (ipCfg->IPMode == IPADDR_USE_STATIC)
{
dhcp_stop(netif);
// SEE bug http://savannah.nongnu.org/bugs/?22804
netif->flags &= ~NETIF_FLAG_DHCP;
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
}
// If we are going to AUTO IP addressing, then disable DHCP, set
// the default addresses, and start AutoIP.
#if LWIP_AUTOIP
else if (ipCfg->IPMode == IPADDR_USE_AUTOIP)
{
dhcp_stop(netif);
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
autoip_start(netif);
}
#endif
break;
}
#endif
// AUTOIP
#if LWIP_AUTOIP
case IPADDR_USE_AUTOIP:
{
//
// If we are going to static IP addressing, then disable AutoIP and
// force the new static IP address.
//
if (ulIPMode == IPADDR_USE_STATIC)
{
autoip_stop(netif);
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
}
//
// If we are going to DHCP addressing, then disable AutoIP, set the
// default addresses, and start dhcp.
//
#if LWIP_DHCP
else if (ulIPMode == IPADDR_USE_AUTOIP)
{
autoip_stop(netif);
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
dhcp_start(netif);
}
#endif
break;
}
#endif
}
}
/**************************************************************************//**
* @brief Initializes the lwIP TCP/IP stack.
* \param pucMAC is a pointer to a six byte array containing the MAC
* address to be used for the interface.
* \param ulIPAddr is the IP address to be used (static).
* \param ulNetMask is the network mask to be used (static).
* \param ulGWAddr is the Gateway address to be used (static).
* \param ulIPMode is the IP Address Mode. \b IPADDR_USE_STATIC will force
* static IP addressing to be used, \b IPADDR_USE_DHCP will force DHCP with
* fallback to Link Local (Auto IP), while \b IPADDR_USE_AUTOIP will force
* Link Local only.
*
* This function performs initialization of the lwIP TCP/IP stack for the
* AX88796 Ethernet MAC, including DHCP and/or AutoIP, as configured.
* \return None.
*****************************************************************************/
void
lwIPInit(const unsigned char *pucMAC, unsigned long ulIPAddr,
unsigned long ulNetMask, unsigned long ulGWAddr,
unsigned long ulIPMode)
{
(void) pucMAC;
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
/* Check the parameters.*/
#if LWIP_DHCP && LWIP_AUTOIP
EFM_ASSERT((ulIPMode == IPADDR_USE_STATIC) ||
(ulIPMode == IPADDR_USE_DHCP) ||
(ulIPMode == IPADDR_USE_AUTOIP));
#elif LWIP_DHCP
EFM_ASSERT((ulIPMode == IPADDR_USE_STATIC) ||
(ulIPMode == IPADDR_USE_DHCP));
#elif LWIP_AUTOIP
EFM_ASSERT((ulIPMode == IPADDR_USE_STATIC) ||
(ulIPMode == IPADDR_USE_AUTOIP));
#else
EFM_ASSERT(ulIPMode == IPADDR_USE_STATIC);
#endif
/* Initialize lwIP library modules */
lwip_init();
/* Setup the network address values.*/
if (ulIPMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(ulIPAddr);
net_mask.addr = htonl(ulNetMask);
gw_addr.addr = htonl(ulGWAddr);
}
#if LWIP_DHCP || LWIP_AUTOIP
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
#endif
/* Create, configure and add the Ethernet controller interface with
* default settings.*/
netif_add(&lwip_netif, &ip_addr, &net_mask, &gw_addr, NULL,
AX88796Cif_init, ip_input);
netif_set_default(&lwip_netif);
/* Start DHCP, if enabled.*/
#if LWIP_DHCP
if (ulIPMode == IPADDR_USE_DHCP)
{
dhcp_start(&lwip_netif);
}
#endif
/* Start AutoIP, if enabled and DHCP is not.*/
#if LWIP_AUTOIP
if (ulIPMode == IPADDR_USE_AUTOIP)
{
autoip_start(&lwip_netif);
}
#endif
/* Bring the interface up.*/
netif_set_up(&lwip_netif);
}
/** Restart AutoIP client and check the next address (conflict detected)
*
* @param netif The netif under AutoIP control
*/
static void
ICACHE_FLASH_ATTR autoip_restart(struct netif *netif)
{
netif->autoip->tried_llipaddr++;
autoip_start(netif);
}
static void
lwIPLinkDetect(void)
{
bool bHaveLink;
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
//
// See if there is an active link.
//
bHaveLink = MAP_EMACPHYRead(EMAC0_BASE, 0, EPHY_BMSR) & EPHY_BMSR_LINKSTAT;
//
// Return without doing anything else if the link state hasn't changed.
//
if(bHaveLink == g_bLinkActive)
{
return;
}
//
// Save the new link state.
//
g_bLinkActive = bHaveLink;
//
// Clear any address information from the network interface.
//
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
//
// See if there is a link now.
//
if(bHaveLink)
{
//
// Start DHCP, if enabled.
//
#if LWIP_DHCP
if(g_ui32IPMode == IPADDR_USE_DHCP)
{
dhcp_start(&g_sNetIF);
}
#endif
//
// Start AutoIP, if enabled and DHCP is not.
//
#if LWIP_AUTOIP
if(g_ui32IPMode == IPADDR_USE_AUTOIP)
{
autoip_start(&g_sNetIF);
}
#endif
}
else
{
//
// Stop DHCP, if enabled.
//
#if LWIP_DHCP
if(g_ui32IPMode == IPADDR_USE_DHCP)
{
dhcp_stop(&g_sNetIF);
}
#endif
//
// Stop AutoIP, if enabled and DHCP is not.
//
#if LWIP_AUTOIP
if(g_ui32IPMode == IPADDR_USE_AUTOIP)
{
autoip_stop(&g_sNetIF);
}
#endif
}
}
void lwIPInit(const unsigned char *pucMAC,
struct ip_addr* ipAddr,
struct ip_addr* netMask,
struct ip_addr* gwAddr,
u8_t ulIPMode)
{
//
// Initialize lwIP library modules
//
lwip_init();
//
// Setup the network address values.
//
#if LWIP_DHCP || LWIP_AUTOIP
if(ulIPMode != IPADDR_USE_STATIC)
{
ipAddr->addr = 0;
netMask->addr = 0;
gwAddr->addr = 0;
}
#endif
//
// Create, configure and add the Ethernet controller interface with
// default settings.
//
lwip_netif.hwaddr[0]=pucMAC[0];
lwip_netif.hwaddr[1]=pucMAC[1];
lwip_netif.hwaddr[2]=pucMAC[2];
lwip_netif.hwaddr[3]=pucMAC[3];
lwip_netif.hwaddr[4]=pucMAC[4];
lwip_netif.hwaddr[5]=pucMAC[5];
netif_add(&lwip_netif, ipAddr, netMask, gwAddr, 0,
enc28j60_if_init, ip_input);
netif_set_default(&lwip_netif);
g_ulIPMode = ulIPMode;
//
// Start DHCP, if enabled.
//
#if LWIP_DHCP
if(g_ulIPMode == IPADDR_USE_DHCP)
{
dhcp_start(&lwip_netif);
}
#endif
//
// Start AutoIP, if enabled and DHCP is not.
//
#if LWIP_AUTOIP
if(g_ulIPMode == IPADDR_USE_AUTOIP)
{
autoip_start(&lwip_netif);
}
#endif
//
// Bring the interface up.
//
netif_set_up(&lwip_netif);
}
//*****************************************************************************
//
//! Initializes the lwIP TCP/IP stack.
//!
//! \param pucMAC is a pointer to a six byte array containing the MAC
//! address to be used for the interface.
//! \param ulIPAddr is the IP address to be used (static).
//! \param ulNetMask is the network mask to be used (static).
//! \param ulGWAddr is the Gateway address to be used (static).
//! \param ulIPMode is the IP Address Mode. \b IPADDR_USE_STATIC will force
//! static IP addressing to be used, \b IPADDR_USE_DHCP will force DHCP with
//! fallback to Link Local (Auto IP), while \b IPADDR_USE_AUTOIP will force
//! Link Local only.
//!
//! This function performs initialization of the lwIP TCP/IP stack for the
//! Stellaris Ethernet MAC, including DHCP and/or AutoIP, as configured.
//!
//! \return None.
//
//*****************************************************************************
void LWIPServiceTaskInit(void *pvParameters)
{
struct ip_addr *ip_addr;
struct ip_addr *net_mask;
struct ip_addr *gw_addr;
//struct ip_addr ip_addr_local;
//struct ip_addr net_mask_local;
char IPState = 0;
char* configLoad;
IP_CONFIG * ipCfg;
printf("Initialisiere IP ");
ipCfg = pvPortMalloc(sizeof(IP_CONFIG));
configLoad = loadFromConfig(IP_CONFIG_FILE, "USE_DHCP");
#ifdef ENABLE_GRAPHIC
vShowBootText("load ipconfig ...");
#endif
printf("LWIPSTACK: LOAD CONFIG: (%s)\n", configLoad);
if (configLoad == 0)
{
IPState = IPADDR_USE_AUTOIP;
}
else if (strcmp(configLoad, "true") == 0)
{
IPState = IPADDR_USE_DHCP;
}
else
{
IPState = IPADDR_USE_STATIC;
}
vPortFree(configLoad);
// Start the TCP/IP thread & init stuff
tcpip_init(NULL, NULL);
vTaskDelay(100 / portTICK_RATE_MS);
// Setup the network address values.
if (IPState == IPADDR_USE_STATIC)
{
ip_addr = getAddresFromConfig("IP_ADDRESS");
net_mask = getAddresFromConfig("IP_SUBNETMASK");
gw_addr = getAddresFromConfig("IP_GATEWAY");
}
#if LWIP_DHCP || LWIP_AUTOIP
else
{
ip_addr = pvPortMalloc(sizeof(struct ip_addr));
net_mask = pvPortMalloc(sizeof(struct ip_addr));
gw_addr = pvPortMalloc(sizeof(struct ip_addr));
}
#endif
// Create, configure and add the Ethernet controller interface with
// default settings.
// WARNING: This must only be run after the OS has been started.
// Typically this is the case, however, if not, you must place this
// in a post-OS initialization
// @SEE http://lwip.wikia.com/wiki/Initialization_using_tcpip.c
printf("Starting NETIF ... \n");
#ifdef ENABLE_GRAPHIC
vShowBootText("starting Network ...");
#endif
netif_add(&lwip_netif, ip_addr, net_mask, gw_addr, NULL, ethernetif_init,
tcpip_input);
netif_set_default(&lwip_netif);
printf("NETIF UP\n");
// Start DHCP, if enabled.
#if LWIP_DHCP
if (IPState == IPADDR_USE_DHCP)
{
#ifdef ENABLE_GRAPHIC
vShowBootText("waiting for DHCP ...");
#endif
printf("Starte DHCP Client ... ");
if (dhcp_start(&lwip_netif) == ERR_OK)
{
printf("[ok]\n");
}
else
{
printf("[fail]\n");
}
}
#endif
// Start AutoIP, if enabled and DHCP is not.
#if LWIP_AUTOIP
if (IPState == IPADDR_USE_AUTOIP)
{
printf ("Setzte Auto IP (NICHT DHCP) ...\n");
autoip_start(&lwip_netif);
}
#endif
if (IPState == IPADDR_USE_STATIC)
{
// Bring the interface up.
netif_set_up(&lwip_netif);
}
vTaskDelay(1000 / portTICK_RATE_MS);
while (0 == netif_is_up(&lwip_netif))
{
vTaskDelay(5000 / portTICK_RATE_MS);
if (0 == netif_is_up(&lwip_netif))
{
dhcp_renew(&lwip_netif);
}
}
printnetif(&lwip_netif);
configLoad = loadFromConfig(IP_CONFIG_FILE, "IS_SERVER");
if (strcmp(configLoad, "true") == 0)
{
/* Initialize HTTP, DNS, SNTP */
printf("HTTPD Starten ...\n");
httpd_init();
}
vPortFree(configLoad);
#if ENABLE_SNTP
printf("SNTP Starten ...\n");
sntp_init();
#endif
#if ENABLE_DNS
printf("DNS Starten ...\n");
dns_init();
#endif
#if ENABLE_NET_BIOS
printf("NETBIOS Starten ...\n");
netbios_init();
#endif
printf("Dienste gestartet ...\n");
#ifdef ENABLE_GRAPHIC
configLoad = loadFromConfig(IP_CONFIG_FILE, "IS_CLIENT");
if (strcmp(configLoad, "true") == 0)
{
vShowBootText("loading menu ...");
vLoadMenu();
}
else
{
vShowBootText("ready for requests ...");
}
vPortFree(configLoad);
#endif
// Nothing else to do. No point hanging around.
while (1)
{
vTaskDelay(500 / portTICK_RATE_MS);
if (EthernetPHYRead(ETH_BASE, PHY_MR1) & ETH_PHY_LINK_UP)
{
if (!(netif_is_up(&lwip_netif)))
{
// set link up flag
netif_set_up(&lwip_netif);
#ifdef ENABLE_GRAPHIC
vShowBootText("activate networkinterface ...");
configLoad = loadFromConfig(IP_CONFIG_FILE, "IS_CLIENT");
if (strcmp(configLoad, "true") == 0)
{
vShowBootText("loading menu ...");
vLoadMenu();
}
else
{
vShowBootText("ready for requests ...");
}
vPortFree(configLoad);
#endif
if (IPState == IPADDR_USE_DHCP)
{
printf("DHCP Adresse anfordern ... ");
if (dhcp_renew(&lwip_netif) == ERR_OK)
{
printf("[ok]\n");
printnetif(&lwip_netif);
}
else
{
printf("[fail]\n");
}
}
}
}
else
{
if (netif_is_up(&lwip_netif))
{
#ifdef ENABLE_GRAPHIC
vShowBootText("no networkconnection!!");
#endif
printf("Deaktiviere Netzwerkinterface ... ");
netif_set_down(&lwip_netif);
}
}
}
}
//*****************************************************************************
//
//! Initializes the lwIP TCP/IP stack.
//! Call it from your main to initialize the lwip
//!
//! \param pucMAC is a pointer to a six byte array containing the MAC
//! address to be used for the interface.
//! \param ulIPAddr is the IP address to be used (static).
//! \param ulNetMask is the network mask to be used (static).
//! \param ulGWAddr is the Gateway address to be used (static).
//! \param ulIPMode is the IP Address Mode. \b IPADDR_USE_STATIC will force
//! static IP addressing to be used, \b IPADDR_USE_DHCP will force DHCP with
//! fallback to Link Local (Auto IP), while \b IPADDR_USE_AUTOIP will force
//! Link Local only.
//!
//! This function performs initialization of the lwIP TCP/IP stack for the
//! Stellaris Ethernet MAC, including DHCP and/or AutoIP, as configured.
//!
//! \return None.
//
//*****************************************************************************
void LWIPServiceTaskInit(IP_CONFIG *ipCfg)
{
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
LWIP_ASSERT("ipCfg != NULL", (ipCfg != NULL));
// Check the parameters.
#if LWIP_DHCP && LWIP_AUTOIP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_DHCP) ||
(ipCfg->IPMode == IPADDR_USE_AUTOIP))
#elif LWIP_DHCP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_DHCP))
#elif LWIP_AUTOIP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_AUTOIP))
#else
ASSERT(ipCfg->IPMode == IPADDR_USE_STATIC)
#endif
LWIP_DEBUGF(DHCP_DEBUG, ("----- LWIP_DEBUGF calling tcpip_init -----\n"));
// Start the TCP/IP thread & init stuff
tcpip_init(NULL, NULL);
vTaskDelay(100 / portTICK_RATE_MS);
// Setup the network address values.
if (ipCfg->IPMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(ipCfg->IPAddr);
net_mask.addr = htonl(ipCfg->NetMask);
gw_addr.addr = htonl(ipCfg->GWAddr);
}
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
// Create, configure and add the Ethernet controller interface with
// default settings.
// WARNING: This must only be run after the OS has been started.
// Typically this is the case, however, if not, you must place this
// in a post-OS initialization
// @SEE http://lwip.wikia.com/wiki/Initialization_using_tcpip.c
netif_add(&lwip_netif, &ip_addr, &net_mask, &gw_addr,
NULL, ethernetif_init, tcpip_input);
netif_set_default(&lwip_netif);
// Start DHCP, if enabled.
#if LWIP_DHCP
if (ipCfg->IPMode == IPADDR_USE_DHCP)
{
LWIP_DEBUGF(DHCP_DEBUG, ("----- Starting DHCP client -----\n"));
dhcp_start(&lwip_netif);
}
#endif
// Start AutoIP, if enabled and DHCP is not.
#if LWIP_AUTOIP
if (ipCfg->IPMode == IPADDR_USE_AUTOIP)
{
autoip_start(&lwip_netif);
}
#endif
if (ipCfg->IPMode == IPADDR_USE_STATIC)
{
// Bring the interface up.
netif_set_up(&lwip_netif);
}
vTaskDelay(1000/portTICK_RATE_MS);
while (0 == netif_is_up(&lwip_netif))
{
lstr("<delay 5s>");
vTaskDelay(5000/portTICK_RATE_MS);
#if LWIP_DHCP
if (ipCfg->IPMode == IPADDR_USE_DHCP) {
if (0 == netif_is_up(&lwip_netif)) {
lstr("<dhcp_renew>");
dhcp_renew(&lwip_netif);
}
}
#endif
}
/* Initialize HTTP */
#ifdef INCLUDE_HTTPD_SSI
init_ssi_cgi_handlers();
#else
#ifdef INCLUDE_HTTPD_CGI
init_ssi_cgi_handlers();
#endif
#endif
httpd_init();
}
/** Restart AutoIP client and check the next address (conflict detected)
*
* @param netif The netif under AutoIP control
*/
static void
autoip_restart(struct netif *netif)
{
netif->autoip->tried_llipaddr++;
autoip_start(netif);
}
/*..........................................................................*/
QState LwIPMgr_running(LwIPMgr *me, QEvt const *e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
#if (LWIP_DHCP != 0)
dhcp_start(me->netif); /* start DHCP if configured */
/* NOTE: If LWIP_AUTOIP is configured in lwipopts.h and
* LWIP_DHCP_AUTOIP_COOP is set as well, the DHCP process will
* start AutoIP after DHCP fails for 59 seconds.
*/
#elif (LWIP_AUTOIP != 0)
autoip_start(me->netif); /* start AutoIP if configured */
#endif
QTimeEvt_postEvery(&me->te_LWIP_SLOW_TICK, (QActive *)me,
(LWIP_SLOW_TICK_MS * BSP_TICKS_PER_SEC) / 1000U);
return Q_HANDLED();
}
case Q_EXIT_SIG: {
QTimeEvt_disarm(&me->te_LWIP_SLOW_TICK);
return Q_HANDLED();
}
case SEND_UDP_SIG: {
if (me->upcb->remote_port != 0U) {
struct pbuf *p = pbuf_new((u8_t *)((TextEvt const *)e)->text,
strlen(((TextEvt const *)e)->text) + 1U);
if (p != (struct pbuf *)0) {
udp_send(me->upcb, p);
pbuf_free(p); /* don't leak the pbuf! */
}
}
return Q_HANDLED();
}
case LWIP_RX_READY_SIG: {
eth_driver_read();
return Q_HANDLED();
}
case LWIP_TX_READY_SIG: {
eth_driver_write();
return Q_HANDLED();
}
case LWIP_SLOW_TICK_SIG: {
/* has IP address changed? */
if (me->ip_addr != me->netif->ip_addr.addr) {
me->ip_addr = me->netif->ip_addr.addr; /* save the IP addr. */
BSP_displyIP(ntohl(me->ip_addr));
}
#if LWIP_TCP
me->tcp_tmr += LWIP_SLOW_TICK_MS;
if (me->tcp_tmr >= TCP_TMR_INTERVAL) {
me->tcp_tmr = 0;
tcp_tmr();
}
#endif
#if LWIP_ARP
me->arp_tmr += LWIP_SLOW_TICK_MS;
if (me->arp_tmr >= ARP_TMR_INTERVAL) {
me->arp_tmr = 0;
etharp_tmr();
}
#endif
#if LWIP_DHCP
me->dhcp_fine_tmr += LWIP_SLOW_TICK_MS;
if (me->dhcp_fine_tmr >= DHCP_FINE_TIMER_MSECS) {
me->dhcp_fine_tmr = 0;
dhcp_fine_tmr();
}
me->dhcp_coarse_tmr += LWIP_SLOW_TICK_MS;
if (me->dhcp_coarse_tmr >= DHCP_COARSE_TIMER_MSECS) {
me->dhcp_coarse_tmr = 0;
dhcp_coarse_tmr();
}
#endif
#if LWIP_AUTOIP
me->auto_ip_tmr += LWIP_SLOW_TICK_MS;
if (me->auto_ip_tmr >= AUTOIP_TMR_INTERVAL) {
me->auto_ip_tmr = 0;
autoip_tmr();
}
#endif
return Q_HANDLED();
}
case LWIP_RX_OVERRUN_SIG: {
LINK_STATS_INC(link.err);
return Q_HANDLED();
}
}
return Q_SUPER(&QHsm_top);
}
