S03_CH08_DMA_LWIP以太网传输

always@(posedge FCLK_CLK1)

begin

if(!peripheral_aresetn) begin //系统复位

S_AXIS_tvalid <= 1'b0;

S_AXIS_tdata <= 32'd0;

S_AXIS_tlast <= 1'b0;

state <=0;

end

else begin

case(state) //状态机

0: begin

if(gpio_tri_o_0&& S_AXIS_tready) begin //当FIFO非满的时候

S_AXIS_tvalid <= 1'b1;//设置写FIFO数据有效标志为1

state <= 1;//转入状态1

end

else begin

S_AXIS_tvalid <= 1'b0;

state <= 0;

end

end

1:begin

if(S_AXIS_tready) begin //当FIFO非满

S_AXIS_tdata <= S_AXIS_tdata + 1'b1;

if(S_AXIS_tdata == 16'd1022) begin //从0-1022一共写入1023个字节

S_AXIS_tlast <= 1'b1;//发送最后一个数据

state <= 2;

end

else begin

S_AXIS_tlast <= 1'b0;

state <= 1;

end

end

else begin

S_AXIS_tdata <= S_AXIS_tdata;                   

state <= 1;

end

end       

2:begin

if(!S_AXIS_tready) begin //如果FIFO满，等待

S_AXIS_tvalid <= 1'b1;

S_AXIS_tlast <= 1'b1;

S_AXIS_tdata <= S_AXIS_tdata;

state <= 2;

end

else begin //写入结束

S_AXIS_tvalid <= 1'b0;

S_AXIS_tlast <= 1'b0;

S_AXIS_tdata <= 16'd0;

state <= 0;

end

end

default: state <=0;

endcase

end              

end

/*

*

* www.osrc.cn

* www.milinker.com

* copyright by nan jin mi lian dian zi www.osrc.cn

* axi dma test

*

*/

#include "dma_intr.h"

#include "timer_intr.h"

#include "sys_intr.h"

#include "xgpio.h"

#include "OLED.h"

#include "lwip/err.h"

#include "lwip/tcp.h"

#include "lwipopts.h"

#include "netif/xadapter.h"

#include "lwipopts.h"

static  XScuGic Intc; //GIC

static  XScuTimer Timer;//timer

XAxiDma AxiDma;

u16 *RxBufferPtr[2];  /* ping pong buffers*/

volatile u32 RX_success;

volatile u32 TX_success;

volatile u32 RX_ready=1;

volatile u32 TX_ready=1;

#define TIMER_LOAD_VALUE    XPAR_CPU_CORTEXA9_0_CPU_CLK_FREQ_HZ / 8 //0.25S

extern void send_received_data(void);

extern unsigned tcp_client_connected;

char oled_str[17]="";

static XGpio Gpio;

#define AXI_GPIO_DEV_ID         XPAR_AXI_GPIO_0_DEVICE_ID

int init_intr_sys(void)

{

DMA_Intr_Init(&AxiDma,0);//initial interrupt system

Timer_init(&Timer,TIMER_LOAD_VALUE,0);

Init_Intr_System(&Intc); // initial DMA interrupt system

Setup_Intr_Exception(&Intc);

DMA_Setup_Intr_System(&Intc,&AxiDma,0,RX_INTR_ID);//setup dma interrpt system

Timer_Setup_Intr_System(&Intc,&Timer,TIMER_IRPT_INTR);

DMA_Intr_Enable(&Intc,&AxiDma);

}

int main(void)

{

int Status;

struct netif *netif, server_netif;

struct ip_addr ipaddr, netmask, gw;

/* the mac address of the board. this should be unique per board */

unsigned char mac_ethernet_address[] = { 0x00, 0x0a, 0x35, 0x00, 0x01, 0x02 };

/* Initialize the ping pong buffers for the data received from axidma */

RxBufferPtr[0] = (u16 *)RX_BUFFER0_BASE;

RxBufferPtr[1] = (u16 *)RX_BUFFER1_BASE;

XGpio_Initialize(&Gpio, AXI_GPIO_DEV_ID);

XGpio_SetDataDirection(&Gpio, 1, 0);

init_intr_sys();

TcpTmrFlag = 0;

netif = &server_netif;

IP4_ADDR(&ipaddr,  192, 168,   1,  10);

IP4_ADDR(&netmask, 255, 255, 255,  0);

IP4_ADDR(&gw,      192, 168,   1,  1);

/*lwip library init*/

lwip_init();

/* Add network interface to the netif_list, and set it as default */

if (!xemac_add(netif, &ipaddr, &netmask, &gw, mac_ethernet_address, XPAR_XEMACPS_0_BASEADDR)) {

xil_printf("Error adding N/W interface\r\n");

return -1;

}

netif_set_default(netif);

/* specify that the network if is up */

netif_set_up(netif);

/* initialize tcp pcb */

tcp_send_init();

XGpio_DiscreteWrite(&Gpio, 1, 1);

oled_fresh_en();// enable oled

Timer_start(&Timer);

while (1)

{

/* call tcp timer every 250ms */

if(TcpTmrFlag)

{

tcp_tmr();

TcpTmrFlag = 0;

}

/*receive input packet from emac*/

xemacif_input(netif);//将MAC队列里的packets传输到你的LwIP/IP stack里

/* if connected to the server, start receive data from PL through axidma, then transmit the data to the PC software by TCP*/

if(tcp_client_connected)

send_received_data();

}

return 0;

}

/*****************************************************************************/

/*

*

* This is the DMA RX interrupt handler function

*

* It gets the interrupt status from the hardware, acknowledges it, and if any

* error happens, it resets the hardware. Otherwise, if a completion interrupt

* is present, then it sets the RxDone flag.

*

* @param Callback is a pointer to RX channel of the DMA engine.

*

* @return None.

*

* @note None.

*

******************************************************************************/

static void DMA_RxIntrHandler(void *Callback)

{

u32 IrqStatus;

int TimeOut;

XAxiDma *AxiDmaInst = (XAxiDma *)Callback;

/* Read pending interrupts */

IrqStatus = XAxiDma_IntrGetIrq(AxiDmaInst, XAXIDMA_DEVICE_TO_DMA);

/* Acknowledge pending interrupts */

XAxiDma_IntrAckIrq(AxiDmaInst, IrqStatus, XAXIDMA_DEVICE_TO_DMA);

/*

* If no interrupt is asserted, we do not do anything

*/

if (!(IrqStatus & XAXIDMA_IRQ_ALL_MASK)) {

return;

}

/*

* If error interrupt is asserted, raise error flag, reset the

* hardware to recover from the error, and return with no further

* processing.

*/

if ((IrqStatus & XAXIDMA_IRQ_ERROR_MASK)) {

xil_printf("rx error! \r\n");

return;

}

/*

* If completion interrupt is asserted, then set RxDone flag

*/

if ((IrqStatus & XAXIDMA_IRQ_IOC_MASK)) {

if(packet_trans_done)

xil_printf("last transmission has not finished!\r\n");

else

/*set the axidma done flag*/

packet_trans_done = 1;

}

}

void send_received_data()

{

#if __arm__

int copy = 3;

#else

int copy = 0;

#endif

err_t err;

int Status;

struct tcp_pcb *tpcb = connected_pcb;

/*initial the first axdma transmission, only excuse once*/

if(!first_trans_start)

{

Status = XAxiDma_SimpleTransfer(&AxiDma, (u32)RxBufferPtr[0],

(u32)(PAKET_LENGTH), XAXIDMA_DEVICE_TO_DMA);

if (Status != XST_SUCCESS)

{

xil_printf("axi dma failed! 0 %d\r\n", Status);

return;

}

/*set the flag, so this part of code will not excuse again*/

first_trans_start = 1;

}

/*if the last axidma transmission is done, the interrupt triggered, then start TCP transmission*/

if(packet_trans_done)

{

if (!connected_pcb)

return;

/* if tcp send buffer has enough space to hold the data we want to transmit from PL, then start tcp transmission*/

if (tcp_sndbuf(tpcb) > SEND_SIZE)

{

/*transmit received data through TCP*/

err = tcp_write(tpcb, RxBufferPtr[packet_index & 1], SEND_SIZE, copy);

if (err != ERR_OK) {

xil_printf("txperf: Error on tcp_write: %d\r\n", err);

connected_pcb = NULL;

return;

}

err = tcp_output(tpcb);

if (err != ERR_OK) {

xil_printf("txperf: Error on tcp_output: %d\r\n",err);

return;

}

packet_index++;

/*clear the axidma done flag*/

packet_trans_done = 0;

/*initial the other axidma transmission when the current transmission is done*/

Status = XAxiDma_SimpleTransfer(&AxiDma, (u32)RxBufferPtr[(packet_index + 1)&1],

(u32)(PAKET_LENGTH), XAXIDMA_DEVICE_TO_DMA);

if (Status != XST_SUCCESS)

{

xil_printf("axi dma %d failed! %d \r\n", (packet_index + 1), Status);

return;

}

}

}

}

static err_t

tcp_connected_callback(void *arg, struct tcp_pcb *tpcb, err_t err)

{

xil_printf("txperf: Connected to iperf server\r\n");

/* store state */

connected_pcb = tpcb;

/* set callback values & functions */

tcp_arg(tpcb, NULL);

tcp_sent(tpcb, tcp_sent_callback);

tcp_client_connected = 1;

/* initiate data transfer */

return ERR_OK;

}

/*this fuction just used to count the tcp transmission times*/

static err_t

tcp_sent_callback(void *arg, struct tcp_pcb *tpcb, u16_t len)

{

tcp_trans_done ++;

return ERR_OK;

}