void FNET_DEBUG_NETBUF_print_chain( fnet_netbuf_t *nb, char *str, int max)
{
int i = 0;
fnet_println("== %s nb = 0x%08X ==", str, (unsigned long)nb);
while(nb->next && i<max)
{
nb = nb->next;
i++;
fnet_println("\t(%d) next = 0x%08X", i, (unsigned long)nb);
}
}
void FNET_DEBUG_NETBUF_print_chain( fnet_netbuf_t *nb, fnet_uint8_t *str, fnet_index_t max)
{
fnet_index_t i = 0u;
fnet_println("== %s nb = 0x%08X ==", str, (fnet_uint32_t)nb);
while(nb->next && i<max)
{
nb = nb->next;
i++;
fnet_println("\t(%d) next = 0x%08X", i, (fnet_uint32_t)nb);
}
}
void fnet_icmp_trace(fnet_uint8_t *str, fnet_icmp_header_t *icmp_hdr)
{
fnet_printf(FNET_SERIAL_ESC_FG_GREEN"%s", str); /* Print app-specific header.*/
fnet_println("[ICMP header]"FNET_SERIAL_ESC_FG_BLACK);
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
fnet_println("|(Type) "FNET_SERIAL_ESC_FG_BLUE"%3u"FNET_SERIAL_ESC_FG_BLACK" |(Code) %3u |(Cheksum) 0x%04x |",
icmp_hdr->type,
icmp_hdr->code,
fnet_ntohs(icmp_hdr->checksum));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
}
/************************************************************************
* NAME: fnet_stack_init
*
* DESCRIPTION: TCP/IP Stack initialization.
************************************************************************/
static fnet_return_t fnet_stack_init( void )
{
fnet_isr_init();
if (fnet_timer_init(FNET_TIMER_PERIOD_MS) == FNET_ERR)
{
goto ERROR;
}
#if FNET_CFG_DEBUG_STARTUP_MS && FNET_CFG_DEBUG
fnet_println("\n Waiting %d Seconds...", FNET_CFG_DEBUG_STARTUP_MS/1000);
fnet_timer_delay(fnet_timer_ms2ticks(FNET_CFG_DEBUG_STARTUP_MS));
#endif
if(fnet_prot_init() == FNET_ERR)
{
goto ERROR;
}
fnet_socket_init();
if(fnet_netif_init_all() == FNET_ERR)
{
goto ERROR;
}
return (FNET_OK);
ERROR:
fnet_stack_release();
return (FNET_ERR);
}
/*FNET_DEBUG("");*/
fnet_isr_unlock();
return (max * mempool->unit_size);
}
#if 0 /* For Debug needs.*/
int fnet_mempool_check( fnet_mempool_desc_t mpool )
{
volatile struct fnet_mempool * mempool = (struct fnet_mempool *)mpool;
volatile fnet_mempool_unit_header_t *t_mem;
int i = 0;
fnet_isr_lock();
t_mem = mempool->free_ptr;
if(t_mem == 0)
return 0;
while(t_mem->ptr != mempool->free_ptr)
{
i++;
if((i>100)||(t_mem->ptr == 0)||(t_mem->ptr == (void *)0xFFFFFFFF))
{
fnet_println("!!!MEMPOOL CRASH!!!");
return FNET_ERR;
}
if( (((unsigned long)t_mem) < (unsigned long)t_mem->ptr) && ((t_mem->size + (unsigned long)t_mem) > (unsigned long)t_mem->ptr))
{
fnet_println("!!!MEMPOOL FREE CRASH!!!");
return FNET_ERR;
}
t_mem = t_mem->ptr;
}
fnet_isr_unlock();
return FNET_OK;
}
void fnet_eth_trace(fnet_uint8_t *str, fnet_eth_header_t *eth_hdr)
{
fnet_uint8_t mac_str[FNET_MAC_ADDR_STR_SIZE];
fnet_printf(FNET_SERIAL_ESC_FG_GREEN"%s", str); /* Print app-specific header.*/
fnet_println("[ETH header]"FNET_SERIAL_ESC_FG_BLACK);
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/\\/\\/\\/-+");
fnet_println("|(Dest) "FNET_SERIAL_ESC_FG_BLUE"%17s"FNET_SERIAL_ESC_FG_BLACK" |", fnet_mac_to_str(eth_hdr->destination_addr, mac_str));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/\\/\\/\\/-+");
fnet_println("|(Src) "FNET_SERIAL_ESC_FG_BLUE"%17s"FNET_SERIAL_ESC_FG_BLACK" |", fnet_mac_to_str(eth_hdr->source_addr, mac_str));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/\\/\\/\\/-+");
fnet_println("|(Type) 0x%04x |", fnet_ntohs(eth_hdr->type));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
}
/************************************************************************
* NAME: fnet_malloc_max
*
* DESCRIPTION: Returns a maximum size of posible allocated memory chunk.
*
*************************************************************************/
fnet_size_t fnet_mempool_malloc_max( fnet_mempool_desc_t mpool )
{
struct fnet_mempool *mempool = (struct fnet_mempool *)mpool;
fnet_size_t max = 0u;
fnet_mempool_unit_header_t *t_mem;
fnet_isr_lock();
t_mem = mempool->free_ptr;
if(t_mem)
{
max = t_mem->size;
#if 0
FNET_DEBUG("%d,", t_mem->size * sizeof(FNET_ALLOC_HDR_T));
#endif
while((t_mem->ptr) && (t_mem->ptr != mempool->free_ptr))
{
t_mem = t_mem->ptr;
if(t_mem->size > max)
{
max = t_mem->size;
}
#if 0
FNET_DEBUG("%d,", t_mem->size * sizeof(FNET_ALLOC_HDR_T));
#endif
}
#if 0
FNET_DEBUG("");
#endif
}
fnet_isr_unlock();
return (max * mempool->unit_size);
}
#if 0 /* For Debug needs.*/
fnet_return_t fnet_mempool_check( fnet_mempool_desc_t mpool )
{
volatile struct fnet_mempool * mempool = (struct fnet_mempool *)mpool;
volatile fnet_mempool_unit_header_t *t_mem;
fnet_index_t i = 0u;
fnet_isr_lock();
t_mem = mempool->free_ptr;
if(t_mem)
{
while(t_mem->ptr != mempool->free_ptr)
{
i++;
if((i>100u)||(t_mem->ptr == 0)||(t_mem->ptr == (void *)0xFFFFFFFF))
{
fnet_println("!!!MEMPOOL CRASH!!!");
return FNET_ERR;
}
if( (((fnet_uint32_t)t_mem) < (fnet_uint32_t)t_mem->ptr) && ((t_mem->size + (fnet_uint32_t)t_mem) > (fnet_uint32_t)t_mem->ptr))
{
fnet_println("!!!MEMPOOL FREE CRASH!!!");
return FNET_ERR;
}
t_mem = t_mem->ptr;
}
}
fnet_isr_unlock();
return FNET_OK;
}
static void fnet_udp_trace(fnet_uint8_t *str, fnet_udp_header_t *udp_hdr)
{
fnet_printf(FNET_SERIAL_ESC_FG_GREEN"%s", str); /* Print app-specific header.*/
fnet_println("[UDP header]"FNET_SERIAL_ESC_FG_BLACK);
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
fnet_println("|(SrcPort) "FNET_SERIAL_ESC_FG_BLUE"%3u"FNET_SERIAL_ESC_FG_BLACK" |(DestPort) "FNET_SERIAL_ESC_FG_BLUE"%3u"FNET_SERIAL_ESC_FG_BLACK" |",
fnet_ntohs(udp_hdr->source_port),
fnet_ntohs(udp_hdr->destination_port));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
fnet_println("|(Lenghth) "FNET_SERIAL_ESC_FG_BLUE"%3u"FNET_SERIAL_ESC_FG_BLACK" |(Checksum) 0x%04X |",
fnet_ntohs(udp_hdr->length),
fnet_ntohs(udp_hdr->checksum));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
}
static void fnet_igmp_trace(char *str, fnet_igmp_header_t *igmp_hdr)
{
char ip_str[FNET_IP4_ADDR_STR_SIZE];
fnet_printf(FNET_SERIAL_ESC_FG_GREEN"%s", str); /* Print app-specific header.*/
fnet_println("[IGMP header]"FNET_SERIAL_ESC_FG_BLACK);
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
fnet_println("|(Type) "FNET_SERIAL_ESC_FG_BLUE"0x%2x"FNET_SERIAL_ESC_FG_BLACK" |(Res Time) %3u |(Cheksum) 0x%04x |",
igmp_hdr->type,
igmp_hdr->max_resp_time,
fnet_ntohs(igmp_hdr->checksum));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
fnet_println("|(Group Addr) "FNET_SERIAL_ESC_FG_BLUE"%15s"FNET_SERIAL_ESC_FG_BLACK" |",
fnet_inet_ntoa(*(struct in_addr *)(&igmp_hdr->group_addr), ip_str));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
}
/************************************************************************
* NAME: fnet_malloc
*
* DESCRIPTION: Allocates memory in the memory pool.
*
*************************************************************************/
#if FNET_MEMPOOL_MALLOC_BEST_CHOICE /* Choose the best. */
void *fnet_mempool_malloc(fnet_mempool_desc_t mpool, unsigned nbytes )
{
struct fnet_mempool * mempool = (struct fnet_mempool *)mpool;
fnet_mempool_unit_header_t *p, *prevp;
fnet_mempool_unit_header_t *best_p =0;
fnet_mempool_unit_header_t *best_p_prev =0;
unsigned nunits;
void * res;
fnet_isr_lock();
nunits = ((nbytes + mempool->unit_size - 1) / mempool->unit_size) + 1;
prevp = mempool->free_ptr;
best_p_prev = prevp;
/* Find the best one. */
for(p = prevp->ptr; ; prevp = p, p = p->ptr)
{
if( (p->size >= nunits) && ( (best_p==0) || ((best_p)&&(best_p->size > p->size)) ) )
{
best_p_prev = prevp;
best_p = p;
}
if(p == mempool->free_ptr)
break; /* End of list is reached. */
}
if(best_p)
{
if(best_p->size == nunits)
{
best_p_prev->ptr = best_p->ptr;
}
else
{
best_p->size -= nunits; /* Put to the top. */
best_p = (fnet_mempool_unit_header_t *)((unsigned long)best_p + best_p->size*mempool->unit_size);
best_p->size = nunits;
}
mempool->free_ptr = best_p_prev;
res = (void *)((unsigned long)best_p + mempool->unit_size);
#if 0 /* Clear mem.*/
fnet_memset_zero( res, (nunits-1)* mempool->unit_size );
#endif
}
else
{
/* Break here to detect allocation errors */
res = 0;
}
#if FNET_DEBUG_MEMPOOL_CHECK
if(res)
{
int i;
for(i=DEBUG_last_free_addr_num; i<DEBUG_ALLOCATED_ADDR_MAX; i++)
{
if(DEBUG_allocated_addr[i].address == 0)
{
/* Save allocated address */
DEBUG_allocated_addr[i].address = res;
DEBUG_allocated_addr[i].size = nunits;
break;
}
}
if( i==DEBUG_ALLOCATED_ADDR_MAX)
fnet_println ("Addr_table_overload!!!");
}
#endif
fnet_isr_unlock();
return res;
}
/************************************************************************
* NAME: fnet_free
*
* DESCRIPTION: Frees memory in the mempool.
*
*************************************************************************/
void fnet_mempool_free( fnet_mempool_desc_t mpool, void *ap )
{
struct fnet_mempool * mempool = (struct fnet_mempool *)mpool;
fnet_mempool_unit_header_t *bp, *p;
if(ap != 0)
{
fnet_isr_lock();
/* Block pointer = allocated memory block addr - allocation unit size.*/
bp = (fnet_mempool_unit_header_t *)((unsigned long)ap - mempool->unit_size); /* Point to block header. */
#if FNET_DEBUG_MEMPOOL_CHECK
{
int i;
for(i=0; i<DEBUG_ALLOCATED_ADDR_MAX; i++)
{
if(DEBUG_allocated_addr[i].address == ap)
{
if(DEBUG_allocated_addr[i].size == bp->size)
{
DEBUG_allocated_addr[i].address = 0; // Clear;
DEBUG_last_free_addr_num = i-50;
if (DEBUG_last_free_addr_num < 0)
DEBUG_last_free_addr_num = 0;
break;
}
else
{
fnet_println ("Wrong free size!!!!!!!!");
break;
}
}
}
if( i==DEBUG_ALLOCATED_ADDR_MAX)
fnet_println ("This addr never allocated before!!!!!!!!");
}
#endif
for (p = mempool->free_ptr; !((bp > p) && (bp < p->ptr)); p = p->ptr)
{
#if FNET_DEBUG_MEMPOOL_CHECK /* Debug Check. */
if( (p <= bp) && ((unsigned long)bp <= ((unsigned long)p + p->size)) )/* The block is already free */
{
fnet_println("Already Free UPS");
fnet_isr_unlock();
return;
}
#endif
if((p >= p->ptr) && ((bp > p) || (bp < p->ptr)))
{
break; /* Freed block at start or end of arena. */
}
}
if((fnet_mempool_unit_header_t *)((unsigned long)bp + bp->size*mempool->unit_size) == p->ptr)
{
bp->size += p->ptr->size;
bp->ptr = p->ptr->ptr;
}
else
{
bp->ptr = p->ptr;
}
if((fnet_mempool_unit_header_t *)((unsigned long)p + p->size*mempool->unit_size) == bp)
{
p->size += bp->size;
p->ptr = bp->ptr;
}
else
{
p->ptr = bp;
}
mempool->free_ptr = p;
fnet_isr_unlock();
}
}
static void fnet_arp_trace(char *str, fnet_arp_header_t *arp_hdr)
{
char mac_str[FNET_MAC_ADDR_STR_SIZE];
char ip_str[FNET_IP4_ADDR_STR_SIZE];
fnet_printf(FNET_SERIAL_ESC_FG_GREEN"%s", str); /* Print app-specific header.*/
fnet_println("[ARP header]"FNET_SERIAL_ESC_FG_BLACK);
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
fnet_println("|(HWType) 0x%04x |(PrType) 0x%04x |",
fnet_ntohs(arp_hdr->hard_type),
fnet_ntohs(arp_hdr->prot_type));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
fnet_println("|(HWSize) 0x%02x |(PrSize) 0x%02x |(Opcode) %5u |",
arp_hdr->hard_size,
arp_hdr->prot_size,
fnet_ntohs(arp_hdr->op));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/\\/\\/\\/-+");
fnet_mac_to_str(arp_hdr->sender_hard_addr, mac_str);
fnet_println("|(SenderHWAddr) "FNET_SERIAL_ESC_FG_BLUE"%17s"FNET_SERIAL_ESC_FG_BLACK" |", mac_str);
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/\\/\\/\\/-+");
fnet_println("|(SenderPrAddr) "FNET_SERIAL_ESC_FG_BLUE"%15s"FNET_SERIAL_ESC_FG_BLACK" |",
fnet_inet_ntoa(*(struct in_addr *)(&arp_hdr->sender_prot_addr), ip_str));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/\\/\\/\\/-+");
fnet_mac_to_str(arp_hdr->target_hard_addr, mac_str);
fnet_println("|(TargetHWAddr) "FNET_SERIAL_ESC_FG_BLUE"%17s"FNET_SERIAL_ESC_FG_BLACK" |", mac_str);
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+/\\/\\/\\/-+");
fnet_println("|(TargetPrAddr) "FNET_SERIAL_ESC_FG_BLUE"%15s"FNET_SERIAL_ESC_FG_BLACK" |",
fnet_inet_ntoa(*(struct in_addr *)(&arp_hdr->targer_prot_addr), ip_str));
fnet_println("+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+");
}
