void rx_ethernet_isr1 (void *context)
{
struct netif * netif = &TSE1netif;
//Poczekanie na zakoñczenie odbióru ramki ethernetowej z³¹czem po³¹czonym z eth_tse1
while (alt_avalon_sgdma_check_descriptor_status(&rx_descriptor1) != 0)
;
//dl odebranej ramki
pklen = IORD_16DIRECT(&(rx_descriptor1.actual_bytes_transferred),0);
//printf("dlugosc odebranych danych to: %d",pklen);
memcpy(tx_frame,rx_frame1,pklen);
p->payload=tx_frame;
ethernet_input(p,netif);
alt_avalon_sgdma_construct_mem_to_stream_desc( &tx_descriptor, &tx_descriptor_end, (alt_u32 *)tx_frame, pklen-4, 0, 1, 1, 0 );
alt_avalon_sgdma_do_async_transfer( sgdma_tx_dev, &tx_descriptor );
while (alt_avalon_sgdma_check_descriptor_status(&tx_descriptor) != 0);
alt_avalon_sgdma_construct_stream_to_mem_desc( &rx_descriptor1, &rx_descriptor_end1, (alt_u32 *)rx_frame1, 0, 0 );
alt_avalon_sgdma_do_async_transfer( sgdma_rx_dev1, &rx_descriptor1 );
p->len=0;
p->tot_len=0;
}
void process_pkt (void *pkt, int len, uint16_t port)
{
struct ether_hdr *eth = (struct ether_hdr *)pkt;
struct pbuf *p = NULL;
int vlanid = 1;
if ((IF_OPER_STATUS(port) == IF_DOWN) ||
(IF_ADMIN_STATUS(port) == IF_DOWN)) {
return;
}
if (IS_MAC_UCAST_MAC (eth->smac.addr)) {
mac_address_update (eth->smac, (uint32_t)port, 1);
#if 0
if (unknown_umac (eth->dmac)) {
/*flood the packet*/
}
#endif
}
if (is_dest_stp_group_address (eth->dmac)) {
stp_rcv_bpdu (pkt, port, vlanid, len);
return;
}
#ifdef CONFIG_OPENSWITCH_TCP_IP
p = allocate_and_cpy_buf_2_pbuf (pkt, len);
if (p)
ethernet_input (p, IF_INFO (port));
#endif
free (pkt);
}
void rx_ethernet_isr (void *context)
{
struct netif * netif = &TSE1netif;
//Poczekanie na zakoñczenie odbioru ramki ethernetowej z³¹czem po³¹czonym z eth_tse
while (alt_avalon_sgdma_check_descriptor_status(&rx_descriptor) != 0)
;
//zapisanie do zmiennej pklen dlugosci odebranej ramki ethernetowej
pklen = IORD_16DIRECT(&(rx_descriptor.actual_bytes_transferred),0);
memcpy(tx_frame,rx_frame,pklen);
p->payload=tx_frame;
// funkcja lwip ethernet_input obslugujaca ramkê Ethernetow¹
ethernet_input(p,netif);
//Wys³anie ramki ethernetowej z³¹czem po³¹czonym z eth_tse1
alt_avalon_sgdma_construct_mem_to_stream_desc( &tx_descriptor1,
&tx_descriptor_end1, (alt_u32 *)tx_frame, pklen-4, 0, 1, 1, 0 );
alt_avalon_sgdma_do_async_transfer( sgdma_tx_dev1, &tx_descriptor1 );
while (alt_avalon_sgdma_check_descriptor_status(&tx_descriptor1) != 0);
//Ponowne skonsturowanie deskryptorów odbiorczych z³¹cza eth_tse
alt_avalon_sgdma_construct_stream_to_mem_desc( &rx_descriptor,
&rx_descriptor_end, (alt_u32 *)rx_frame, 0, 0 );
alt_avalon_sgdma_do_async_transfer( sgdma_rx_dev, &rx_descriptor );
//wyzerowanie pól z d³ugociami bufora lwIP
p->len=0;
p->tot_len=0;
}
/**
* @ingroup lwip_nosys
* Forwards a received packet for input processing with
* ethernet_input() or ip_input() depending on netif flags.
* Don't call directly, pass to netif_add() and call
* netif->input().
* Only works if the netif driver correctly sets
* NETIF_FLAG_ETHARP and/or NETIF_FLAG_ETHERNET flag!
*/
err_t
netif_input(struct pbuf *p, struct netif *inp)
{
#if LWIP_ETHERNET
if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {
return ethernet_input(p, inp);
} else
#endif /* LWIP_ETHERNET */
return ip_input(p, inp);
}
static void netfront_input(struct netif *netif, unsigned char* data, int len) {
struct eth_hdr *ethhdr;
struct pbuf *p, *q;
int ret;
#if ETH_PAD_SIZE
len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
#endif
/* move received packet into a new pbuf */
mutexLock(g_netBH_lock);
p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
mutexUnLock(g_netBH_lock);
if (p == NULL) {
LINK_STATS_INC(link.memerr);
LINK_STATS_INC(link.drop);
error_mem++;
return;
}
#if ETH_PAD_SIZE
pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
#endif
/* We iterate over the pbuf chain until we have read the entire
* packet into the pbuf. */
for (q = p; q != NULL && len > 0; q = q->next) {
/* Read enough bytes to fill this pbuf in the chain. The
* available data in the pbuf is given by the q->len
* variable. */
ut_memcpy(q->payload, data, len < q->len ? len : q->len);
data += q->len;
len -= q->len;
}
#if ETH_PAD_SIZE
pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
#endif
LINK_STATS_INC(link.recv);
/* points to packet payload, which starts with an Ethernet header */
ethhdr = p->payload;
mutexLock(g_netBH_lock);
if (ethernet_input(p, netif) != ERR_OK){
BUG();
pbuf_free(p);
}
mutexUnLock(g_netBH_lock);
}
//
// Process an incoming IP or ethernet packet.
//
static err_t
simple_input(struct pbuf *p, struct netif *netif)
{
#if LWIP_ARP
if (netif->flags & NETIF_FLAG_ETHARP) {
ethernet_input(p, netif);
} else
#endif
{
ip_input(p, netif);
}
return ERR_OK;
}
/**
* This function should be called when a packet is ready to be read
* from the interface. It uses the function low_level_input() that
* should handle the actual reception of bytes from the network
* interface. Then the type of the received packet is determined and
* the appropriate input function is called.
*
* @param netif the lwip network interface structure for this ethernetif
*/
void enc28j60_if_input(struct netif *netif)
{
struct ethernetif *ethernetif;
struct eth_hdr *ethhdr;
struct pbuf *p;
ethernetif = netif->state;
/* move received packet into a new pbuf */
p = low_level_input(netif);
/* no packet could be read, silently ignore this */
if (p == NULL) return;
/* points to packet payload, which starts with an Ethernet header */
ethhdr = p->payload;
switch(htons(ethhdr->type)) {
/* IP packet? */
case ETHTYPE_IP:
#if 0
/* CSi disabled ARP table update on ingress IP packets.
This seems to work but needs thorough testing. */
/* update ARP table */
etharp_ip_input(netif, p);
#endif
/* skip Ethernet header */
pbuf_header(p, -(s16_t)sizeof(struct eth_hdr));
LWIP_DEBUGF(NETIF_DEBUG,("enc28j60_if_input: passing packet up to IP\n"));
// pbuf_free(p);
/* pass to network layer */
netif->input(p, netif);
break;
/* ARP packet? */
case ETHTYPE_ARP:
/* pass p to ARP module */
ethernet_input(p, netif);
break;
/* unsupported Ethernet packet type */
default:
/* free pbuf */
pbuf_free(p);
p = NULL;
break;
}
}
/*..........................................................................*/
void eth_driver_read(void) {
struct pbuf *p = low_level_receive();
if (p != NULL) { /* new packet received into the pbuf? */
if (ethernet_input(p, &l_netif) != ERR_OK) { /* pbuf not handled? */
LWIP_DEBUGF(NETIF_DEBUG, ("eth_driver_input: input error\n"));
pbuf_free(p); /* free the pbuf */
}
/* try to output a packet if TX fifo is empty and pbuf is available */
if ((ETH->TR & MAC_TR_NEWTX) == 0) {
p = l_txq.get();
if (p != NULL) {
low_level_transmit(p);
pbuf_free(p); /* free the pbuf, lwIP knows nothing of it */
}
}
}
ETH->IM |= ETH_INT_RX; /* re-enable the RX interrupt */
}
/**
* Pass a received packet to tcpip_thread for input processing
*
* @param p the received packet, p->payload pointing to the Ethernet header or
* to an IP header (if inp doesn't have NETIF_FLAG_ETHARP or
* NETIF_FLAG_ETHERNET flags)
* @param inp the network interface on which the packet was received
*/
err_t
tcpip_input(struct pbuf *p, struct netif *inp)
{
#if LWIP_TCPIP_CORE_LOCKING_INPUT
err_t ret;
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_input: PACKET %p/%p\n", (void *)p, (void *)inp));
LOCK_TCPIP_CORE();
#if LWIP_ETHERNET
if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {
ret = ethernet_input(p, inp);
} else
#endif /* LWIP_ETHERNET */
{
ret = ip_input(p, inp);
}
UNLOCK_TCPIP_CORE();
return ret;
#else /* LWIP_TCPIP_CORE_LOCKING_INPUT */
struct tcpip_msg *msg;
if (sys_mbox_valid(&mbox)) {
msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_INPKT);
if (msg == NULL) {
return ERR_MEM;
}
msg->type = TCPIP_MSG_INPKT;
#ifdef __ADSPBLACKFIN__
msg->flags = 0;
#endif
msg->msg.inp.p = p;
msg->msg.inp.netif = inp;
if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {
memp_free(MEMP_TCPIP_MSG_INPKT, msg);
return ERR_MEM;
}
return ERR_OK;
}
return ERR_VAL;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
}
/**
* This function should be called when a packet is ready to be read
* from the interface. It uses the function low_level_input() that
* should handle the actual reception of bytes from the network
* interface. Then the type of the received packet is determined and
* the appropriate input function is called.
*
* @param netif the lwip network interface structure for this ethernetif
*/
int
stellarisif_input(struct netif *netif)
{
struct ethernetif *ethernetif;
struct pbuf *p;
int count = 0;
ethernetif = netif->state;
/* move received packet into a new pbuf */
while((p = dequeue_packet(ðernetif->rxq)) != NULL) {
count++;
/* process the packet. */
if (ethernet_input(p, netif)!=ERR_OK) {
LWIP_DEBUGF(NETIF_DEBUG, ("stellarisif_input: input error\n"));
pbuf_free(p);
p = NULL;
}
}
return(count);
}
static void
create_arp_response(ip_addr_t *adr)
{
int k;
struct eth_hdr *ethhdr;
struct etharp_hdr *etharphdr;
struct pbuf *p = pbuf_alloc(PBUF_RAW, sizeof(struct eth_hdr) + sizeof(struct etharp_hdr), PBUF_RAM);
if(p == NULL) {
FAIL_RET();
}
ethhdr = (struct eth_hdr*)p->payload;
etharphdr = (struct etharp_hdr*)(ethhdr + 1);
ethhdr->dest = test_ethaddr;
ethhdr->src = test_ethaddr2;
ethhdr->type = htons(ETHTYPE_ARP);
etharphdr->hwtype = htons(/*HWTYPE_ETHERNET*/ 1);
etharphdr->proto = htons(ETHTYPE_IP);
etharphdr->hwlen = ETHARP_HWADDR_LEN;
etharphdr->protolen = sizeof(ip_addr_t);
etharphdr->opcode = htons(ARP_REPLY);
SMEMCPY(ðarphdr->sipaddr, adr, sizeof(ip_addr_t));
SMEMCPY(ðarphdr->dipaddr, &test_ipaddr, sizeof(ip_addr_t));
k = 6;
while(k > 0) {
k--;
/* Write the ARP MAC-Addresses */
etharphdr->shwaddr.addr[k] = test_ethaddr2.addr[k];
etharphdr->dhwaddr.addr[k] = test_ethaddr.addr[k];
/* Write the Ethernet MAC-Addresses */
ethhdr->dest.addr[k] = test_ethaddr.addr[k];
ethhdr->src.addr[k] = test_ethaddr2.addr[k];
}
ethernet_input(p, &test_netif);
}
/* ethernet buffer */
void eth_rx_thread_entry(void* parameter)
{
struct eth_device* device;
while (1)
{
if (rt_mb_recv(ð_rx_thread_mb, (rt_uint32_t*)&device, RT_WAITING_FOREVER) == RT_EOK)
{
struct pbuf *p;
/* receive all of buffer */
while (1)
{
p = device->eth_rx(&(device->parent));
if (p != RT_NULL)
{
/* notify to upper layer */
ethernet_input(p, device->netif);
}
else break;
}
}
}
}
/**
* The main lwIP thread. This thread has exclusive access to lwIP core functions
* (unless access to them is not locked). Other threads communicate with this
* thread using message boxes.
*
* It also starts all the timers to make sure they are running in the right
* thread context.
*
* @param arg unused argument
*/
static void
tcpip_thread(void *arg)
{
struct tcpip_msg *msg;
LWIP_UNUSED_ARG(arg);
#if IP_REASSEMBLY
sys_timeout(IP_TMR_INTERVAL, ip_reass_timer, NULL);
#endif /* IP_REASSEMBLY */
#if LWIP_ARP
sys_timeout(ARP_TMR_INTERVAL, arp_timer, NULL);
#endif /* LWIP_ARP */
#if LWIP_DHCP
sys_timeout(DHCP_COARSE_TIMER_MSECS, dhcp_timer_coarse, NULL);
sys_timeout(DHCP_FINE_TIMER_MSECS, dhcp_timer_fine, NULL);
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
sys_timeout(AUTOIP_TMR_INTERVAL, autoip_timer, NULL);
#endif /* LWIP_AUTOIP */
#if LWIP_IGMP
sys_timeout(IGMP_TMR_INTERVAL, igmp_timer, NULL);
#endif /* LWIP_IGMP */
#if LWIP_DNS
sys_timeout(DNS_TMR_INTERVAL, dns_timer, NULL);
#endif /* LWIP_DNS */
if (tcpip_init_done != NULL) {
tcpip_init_done(tcpip_init_done_arg);
}
LOCK_TCPIP_CORE();
while (1) { /* MAIN Loop */
sys_mbox_fetch(mbox, (void *)&msg);
switch (msg->type) {
#if LWIP_NETCONN
case TCPIP_MSG_API:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));
msg->msg.apimsg->function(&(msg->msg.apimsg->msg));
break;
#endif /* LWIP_NETCONN */
case TCPIP_MSG_INPKT:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
#if LWIP_ARP
if (msg->msg.inp.netif->flags & NETIF_FLAG_ETHARP) {
ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);
} else
#endif /* LWIP_ARP */
{ ip_input(msg->msg.inp.p, msg->msg.inp.netif);
}
memp_free(MEMP_TCPIP_MSG_INPKT, msg);
break;
#if LWIP_NETIF_API
case TCPIP_MSG_NETIFAPI:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: Netif API message %p\n", (void *)msg));
msg->msg.netifapimsg->function(&(msg->msg.netifapimsg->msg));
break;
#endif /* LWIP_NETIF_API */
case TCPIP_MSG_CALLBACK:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));
msg->msg.cb.f(msg->msg.cb.ctx);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
case TCPIP_MSG_TIMEOUT:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
case TCPIP_MSG_UNTIMEOUT:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg));
sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
default:
break;
}
}
}
/**
* The main lwIP thread. This thread has exclusive access to lwIP core functions
* (unless access to them is not locked). Other threads communicate with this
* thread using message boxes.
*
* It also starts all the timers to make sure they are running in the right
* thread context.
*
* @param arg unused argument
*/
static void
tcpip_thread(void *arg)
{
struct tcpip_msg *msg;
LWIP_UNUSED_ARG(arg);
if (tcpip_init_done != NULL) {
tcpip_init_done(tcpip_init_done_arg);
}
LOCK_TCPIP_CORE();
while (1) { /* MAIN Loop */
UNLOCK_TCPIP_CORE();
LWIP_TCPIP_THREAD_ALIVE();
/* wait for a message, timeouts are processed while waiting */
sys_timeouts_mbox_fetch(&mbox, (void **)&msg);
LOCK_TCPIP_CORE();
switch (msg->type) {
#if LWIP_NETCONN
case TCPIP_MSG_API:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));
msg->msg.apimsg->function(&(msg->msg.apimsg->msg));
break;
#endif /* LWIP_NETCONN */
#if !LWIP_TCPIP_CORE_LOCKING_INPUT
case TCPIP_MSG_INPKT:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
#if LWIP_ETHERNET
if (msg->msg.inp.netif->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {
ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);
} else
#endif /* LWIP_ETHERNET */
{
ip_input(msg->msg.inp.p, msg->msg.inp.netif);
}
memp_free(MEMP_TCPIP_MSG_INPKT, msg);
break;
#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */
#if LWIP_NETIF_API
case TCPIP_MSG_NETIFAPI:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: Netif API message %p\n", (void *)msg));
msg->msg.netifapimsg->function(&(msg->msg.netifapimsg->msg));
break;
#endif /* LWIP_NETIF_API */
case TCPIP_MSG_CALLBACK:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));
msg->msg.cb.function(msg->msg.cb.ctx);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
#if LWIP_TCPIP_TIMEOUT
case TCPIP_MSG_TIMEOUT:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
case TCPIP_MSG_UNTIMEOUT:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg));
sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
#endif /* LWIP_TCPIP_TIMEOUT */
default:
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: %d\n", msg->type));
LWIP_ASSERT("tcpip_thread: invalid message", 0);
break;
}
}
}
/**
* The main lwIP thread. This thread has exclusive access to lwIP core functions
* (unless access to them is not locked). Other threads communicate with this
* thread using message boxes.
*
* It also starts all the timers to make sure they are running in the right
* thread context.
*
* @param arg unused argument
*/
static void
tcpip_thread(void *arg)
{
struct tcpip_msg *msg;
LWIP_UNUSED_ARG(arg);
#if IP_REASSEMBLY
sys_timeout(IP_TMR_INTERVAL, ip_reass_timer, NULL);
#endif /* IP_REASSEMBLY */
#if LWIP_ARP
sys_timeout(ARP_TMR_INTERVAL, arp_timer, NULL);
#endif /* LWIP_ARP */
#if LWIP_DHCP
sys_timeout(DHCP_COARSE_TIMER_MSECS, dhcp_timer_coarse, NULL);
sys_timeout(DHCP_FINE_TIMER_MSECS, dhcp_timer_fine, NULL);
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
sys_timeout(AUTOIP_TMR_INTERVAL, autoip_timer, NULL);
#endif /* LWIP_AUTOIP */
#if LWIP_IGMP
sys_timeout(IGMP_TMR_INTERVAL, igmp_timer, NULL);
#endif /* LWIP_IGMP */
#if LWIP_DNS
sys_timeout(DNS_TMR_INTERVAL, dns_timer, NULL);
#endif /* LWIP_DNS */
if (tcpip_init_done != NULL) {
tcpip_init_done(tcpip_init_done_arg);
}
LOCK_TCPIP_CORE();
while (1) { /* MAIN Loop */
sys_mbox_fetch(mbox, (void *)&msg);
// teset by pegasus
//if (msg->msg.apimsg->msg.msg.w.dataptr == &htmldata)
// acoral_print("\nhtmldata:\n");//*,msg->msg.apimsg->msg.msg.w.dataptr);
switch (msg->type) {
#if LWIP_NETCONN
case TCPIP_MSG_API:
//lwip_printf("\r\n1\r\n");
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg));
msg->msg.apimsg->function(&(msg->msg.apimsg->msg));
//acoral_print("\r\n%x\r\n",msg->msg.apimsg->function);
//acoral_print("MSG_API:%s",msg->msg.apimsg->msg.w.dataptr);
break;
#endif /* LWIP_NETCONN */
case TCPIP_MSG_INPKT:
//lwip_printf("\r\n2\r\n");
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg));
#if LWIP_ARP
if (msg->msg.inp.netif->flags & NETIF_FLAG_ETHARP) {
ethernet_input(msg->msg.inp.p, msg->msg.inp.netif);
} else
#endif /* LWIP_ARP */
{//acoral_print("\nip_input:2==2\n");
ip_input(msg->msg.inp.p, msg->msg.inp.netif);
}
memp_free(MEMP_TCPIP_MSG_INPKT, msg);
break;
#if LWIP_NETIF_API
case TCPIP_MSG_NETIFAPI:
//lwip_printf("\r\n3\r\n");
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: Netif API message %p\n", (void *)msg));
msg->msg.netifapimsg->function(&(msg->msg.netifapimsg->msg));
break;
#endif /* LWIP_NETIF_API */
case TCPIP_MSG_CALLBACK:
//lwip_printf("\r\n4\r\n");
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg));
msg->msg.cb.f(msg->msg.cb.ctx);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
case TCPIP_MSG_TIMEOUT:
//lwip_printf("\r\n5\r\n");
LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg));
if(msg->msg.tmo.msecs != 0xffffffff)
sys_timeout (msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg);
else
sys_untimeout (msg->msg.tmo.h, msg->msg.tmo.arg);
memp_free(MEMP_TCPIP_MSG_API, msg);
break;
default:
//lwip_printf("\r\n=======================\r\n");
pbuf_free(msg->msg.inp.p);
break;
}
}
}
void eth_poll() {
struct eth_hdr *ethhdr;
struct pbuf *frame, *p;
int len, read;
while((len = pEth->receive()) != 0) {
frame = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
if(frame == NULL) {
return;
}
p = frame;
/* no packet could be read, silently ignore this */
if (p == NULL) return;
do {
read = pEth->read((char *)p->payload, p->len);
p = p->next;
} while(p != NULL && read != 0);
#if ETH_PAD_SIZE
pbuf_header(p, ETH_PAD_SIZE);
#endif
ethhdr = (struct eth_hdr *)(frame->payload);
// show((char*)ethhdr, 13);
/*
switch(htons(ethhdr->type)) {
case ETHTYPE_IP:
etharp_ip_input(gnetif, frame);
pbuf_header(frame, -((s16_t) sizeof(struct eth_hdr)));
gnetif->input(frame, gnetif);
break;
case ETHTYPE_ARP:
etharp_arp_input(gnetif, (struct eth_addr *)(gnetif->hwaddr), frame);
break;
default:
break;
}*/
//ethernet_input(frame, gnetif);
switch (htons(ethhdr->type)) {
/* IP or ARP packet? */
case ETHTYPE_IP:
case ETHTYPE_ARP:
#if PPPOE_SUPPORT
/* PPPoE packet? */
case ETHTYPE_PPPOEDISC:
case ETHTYPE_PPPOE:
#endif /* PPPOE_SUPPORT */
/* full packet send to tcpip_thread to process */
//if (netif->input(p, gnetif)!=ERR_OK)
if (ethernet_input(frame, eth_netif)!=ERR_OK)
{ LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
pbuf_free(frame);
frame = NULL;
}
break;
default:
pbuf_free(frame);
frame = NULL;
break;
}
/* pbuf_free(frame); */
}
}
//
// Polls the lwIP stack.
//
void
cyg_lwip_simple_poll(void)
{
cyg_tick_count_t ticks;
cyg_uint32 delta;
int i;
#if LWIP_HAVE_SLIPIF && defined(CYGIMP_LWIP_SLIPIF_INSTANCE)
// Poll SLIP device
slipif_poll(&slipif);
#endif
#if PPP_SUPPORT
// Poll PPP device
#endif
#ifdef CYGPKG_LWIP_ETH
{
cyg_netdevtab_entry_t *t;
// Poll ethernet devices
for (t = &__NETDEVTAB__[0]; t != &__NETDEVTAB_END__; t++) {
struct eth_drv_sc *sc = (struct eth_drv_sc *)t->device_instance;
if (sc->state & ETH_DRV_NEEDS_DELIVERY) {
#if defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT)
cyg_bool was_ctrlc_int;
#endif
sc->state &= ~ETH_DRV_NEEDS_DELIVERY;
#if defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT)
was_ctrlc_int = HAL_CTRLC_CHECK(sc->funs->int_vector(sc),
(int) sc);
if (!was_ctrlc_int) // Fall through and run normal code
#endif
sc->funs->deliver(sc);
}
}
// Deliver received packets
while (recv_packet_count > 0) {
ethernet_input(recv_packet[recv_packet_read].p,
recv_packet[recv_packet_read].netif);
recv_packet_read = (recv_packet_read + 1) % MAX_RECV_PACKETS;
recv_packet_count--;
}
}
#endif
// Process timers
ticks = cyg_current_time();
delta = TICKS_TO_MS(ticks - last_ticks);
last_ticks = ticks;
// The following check 'delta > 0' rejects a potential wrap-around in the
// system ticks counter.
if (delta > 0) {
for (i = 0; i < NUM_LWIP_TIMERS; i++) {
lwip_timers[i].time += delta;
if (lwip_timers[i].time >= lwip_timers[i].interval) {
lwip_timers[i].timer_func();
lwip_timers[i].time -= lwip_timers[i].interval;
}
}
}
}
/**
* Process tx and rx packets at the low-level interrupt.
*
* Should be called from the Stellaris Ethernet Interrupt Handler. This
* function will read packets from the Stellaris Ethernet fifo and place them
* into a pbuf queue. If the transmitter is idle and there is at least one packet
* on the transmit queue, it will place it in the transmit fifo and start the
* transmitter.
*
*/
void
stellarisif_interrupt(struct netif *netif)
{
struct stellarisif *stellarisif;
struct pbuf *p;
/* setup pointer to the if state data */
stellarisif = netif->state;
/**
* Process the transmit and receive queues as long as there is receive
* data available
*
*/
p = stellarisif_receive(netif);
while(p != NULL) {
/* process the packet */
#if NO_SYS
if(ethernet_input(p, netif)!=ERR_OK) {
#else
if(tcpip_input(p, netif)!=ERR_OK) {
#endif
/* drop the packet */
LWIP_DEBUGF(NETIF_DEBUG, ("stellarisif_input: input error\n"));
pbuf_free(p);
/* Adjust the link statistics */
LINK_STATS_INC(link.memerr);
LINK_STATS_INC(link.drop);
}
/* Check if TX fifo is empty and packet available */
if((HWREG(ETH_BASE + MAC_O_TR) & MAC_TR_NEWTX) == 0) {
p = dequeue_packet(&stellarisif->txq);
if(p != NULL) {
stellarisif_transmit(netif, p);
}
}
/* Read another packet from the RX fifo */
p = stellarisif_receive(netif);
}
/* One more check of the transmit queue/fifo */
if((HWREG(ETH_BASE + MAC_O_TR) & MAC_TR_NEWTX) == 0) {
p = dequeue_packet(&stellarisif->txq);
if(p != NULL) {
stellarisif_transmit(netif, p);
}
}
}
#if NETIF_DEBUG
/* Print an IP header by using LWIP_DEBUGF
* @param p an IP packet, p->payload pointing to the IP header
*/
void
stellarisif_debug_print(struct pbuf *p)
{
struct eth_hdr *ethhdr = (struct eth_hdr *)p->payload;
u16_t *plen = (u16_t *)p->payload;
LWIP_DEBUGF(NETIF_DEBUG, ("ETH header:\n"));
LWIP_DEBUGF(NETIF_DEBUG, ("Packet Length:%5"U16_F" \n",*plen));
LWIP_DEBUGF(NETIF_DEBUG, ("Destination: %02"X8_F"-%02"X8_F"-%02"X8_F"-%02"X8_F"-%02"X8_F"-%02"X8_F"\n",
ethhdr->dest.addr[0],
ethhdr->dest.addr[1],
ethhdr->dest.addr[2],
ethhdr->dest.addr[3],
ethhdr->dest.addr[4],
ethhdr->dest.addr[5]));
LWIP_DEBUGF(NETIF_DEBUG, ("Source: %02"X8_F"-%02"X8_F"-%02"X8_F"-%02"X8_F"-%02"X8_F"-%02"X8_F"\n",
ethhdr->src.addr[0],
ethhdr->src.addr[1],
ethhdr->src.addr[2],
ethhdr->src.addr[3],
ethhdr->src.addr[4],
ethhdr->src.addr[5]));
LWIP_DEBUGF(NETIF_DEBUG, ("Packet Type:0x%04"U16_F" \n", ethhdr->type));
}
