Subversion Repositories 1g_ethernet_dpi

 
#include <stdio.h>
 
#include "xil_types.h"
#include "xil_io.h"
 
#include "xparameters.h" // XPAR_TMEMAC_0_BASEADDR, XPAR_AXIDMA_0_DEVICE_ID, XPAR_BRAM_0_BASEADDR
#include "xaxidma.h" // XAxiDma_LookupConfig, ..
 
#include "net.h"
#include "arp.h"
#include "ip.h"
#include "icmp.h"
 
// NET-IF
net_if_t net_if;
u8 mac_addr[8];
 
// DMA 
XAxiDma AxiDma;
XAxiDma_Config *CfgPtr;
 
// BUFF
UINTPTR tx_buff;
UINTPTR rx_buff;
int rx_len;
 
// ??
int mac_raw_send(char *data_i, int data_bytes);    // net_init
void low_level_input(char *buff);             // net_input
 
 
// net-stack INIT
int net_init(tmemac_cfg_t *iv_tmemac_cfg, u32 pkt_tx, u32 pkt_rx)
{
    int result;
 
    // DMA init
    CfgPtr = XAxiDma_LookupConfig(XPAR_AXIDMA_0_DEVICE_ID);
    if (!CfgPtr) { return -1; }
 
    result = XAxiDma_CfgInitialize(&AxiDma, CfgPtr);
    if (result != XST_SUCCESS) { return -2; }
 
    XAxiDma_IntrDisable(&AxiDma, XAXIDMA_IRQ_ALL_MASK, XAXIDMA_DEVICE_TO_DMA); // Disable interrupts, we use polling mode
    XAxiDma_IntrDisable(&AxiDma, XAXIDMA_IRQ_ALL_MASK, XAXIDMA_DMA_TO_DEVICE); // ..
 
    tx_buff = (UINTPTR)pkt_tx;
    rx_buff = (UINTPTR)pkt_rx;
    rx_len = 0;
 
    result = XAxiDma_SimpleTransfer(&AxiDma,(UINTPTR)rx_buff, 1024, XAXIDMA_DEVICE_TO_DMA);
    if (result) {
        return -3;
    }
 
    // ETH init
    result = tri_mode_emac_init(iv_tmemac_cfg);
    if (result) {
        return -4;
    }
 
    // NET-IF init
    //  ip
    net_if.ip_addr = htonl(iv_tmemac_cfg->ip_addr);
    //  mac
    mac_addr[0] = ((iv_tmemac_cfg->mac_high) >>  8) & 0xFF;
    mac_addr[1] = ((iv_tmemac_cfg->mac_high) >>  0) & 0xFF;
    mac_addr[2] = ((iv_tmemac_cfg->mac_low ) >> 24) & 0xFF;
    mac_addr[3] = ((iv_tmemac_cfg->mac_low ) >> 16) & 0xFF;
    mac_addr[4] = ((iv_tmemac_cfg->mac_low ) >>  8) & 0xFF;
    mac_addr[5] = ((iv_tmemac_cfg->mac_low ) >>  0) & 0xFF;
    net_if.mac_addr = &mac_addr[0];
    //  raw_send
    net_if.net_raw_send = mac_raw_send;
 
    // ARP
    eth_arp_init(&net_if);
    // IP
    eth_ip_init(&net_if);
    // ICMP
    eth_icmp_init(&net_if);
 
    // Final
    return 0;
}
// poll income-pkt
int net_input(char *buff)
{
    // rx
    low_level_input(buff);
    // prep-len
    int len = rx_len; 
    rx_len = 0;
    // Final
    return len;
}
 
 
// tbd
void low_level_input(char *buff)
{
    // dec vars
    int i, result;
 
    // check Dma_Busy
    if (XAxiDma_Busy(&AxiDma, XAXIDMA_DEVICE_TO_DMA)) {
        return;
    }
 
    // if we are here -> check dma-status
    result = XAxiDma_IntrGetIrq(&AxiDma, XAXIDMA_DEVICE_TO_DMA);
    if (result & XAXIDMA_IRQ_ERROR_MASK) {
        rx_len = -1;
        return;
    }
    if (result & XAXIDMA_IRQ_IOC_MASK){
        // if we are here  we have rxd / cp 1st 512B to USER-buff
        u32 *tmp = (u32 *)buff;
        for (i = 0; i < 512/4; i++){
            *tmp = Xil_In32(rx_buff+(i*4));
            tmp++;
        }
        rx_len = 512/4;
    }
 
    // irq-ack
    XAxiDma_IntrAckIrq(&AxiDma, XAXIDMA_IRQ_ALL_MASK, XAXIDMA_DEVICE_TO_DMA);
    // restart dma
    result = XAxiDma_SimpleTransfer(&AxiDma,(UINTPTR)rx_buff, 1024, XAXIDMA_DEVICE_TO_DMA);
    // Final
    rx_len = (result == XST_SUCCESS)? rx_len : -2;
}
// eth-tx data via {DMA+MAC}
int mac_raw_send(char *data_i, int data_bytes)
{
    // dec vars
    int i, len_dw, len_b;
    u32 *odata_dw, *idata_dw;
    u8  *odata_b,  *idata_b;
 
    // chk
    if ((long)data_i & 0x03) { // DW-align
        xil_printf("ERR: tx-buff addr\n\r");
        return -1;
    }
    // prep
    len_dw = data_bytes / 4;
    len_b  = data_bytes & (4-1);
    // #0 - copy main DW-body
    odata_dw = (u32 *)tx_buff;
    idata_dw = (u32 *)data_i;
    for (i = 0; i < len_dw; i++) {
        Xil_Out32((long)odata_dw, *idata_dw);
        odata_dw++; idata_dw++;
    }
    // #1 - copy BYTE-tail
    if (len_b) { // always DW-aligned
        Xil_Out32((long)odata_dw, *idata_dw);
    }
/*
    odata_b = (u8 *)odata_dw;
    idata_b = (u8 *)idata_dw;
    for (i = 0; i < len_b; i++) {
        Xil_Out8((long)odata_b, *idata_b);
        odata_b++; idata_b++;
    }
*/
 
    // tx
    i = XAxiDma_SimpleTransfer(&AxiDma, tx_buff, data_bytes, XAXIDMA_DMA_TO_DEVICE);
    // Final
    return i;
}