ZYNQ 7020 AXI_DMA 及LWIP使用问题请教

XMFPGA

大家好，想请教一下，我在做一个pl从上位机收数据用dma发送给ps端通过用网口发送的小工程，在《DMA_LWIP》例程外我加了个fifo，现在数据能发送但是有错误，用ila检查发现是因为axi stream data fifo没有正常写入，S_AXIS_tready信号突然拉低，导致我添加的fifo溢出 ，想请教一下是什么原因导致写入的问题以及该怎么解决呢？ 谢谢各位!

ila图中可以根据我从axi_data_fifo中接出的axis_wr_data_count信号，发现数据并没有正确的给dma，每次传输只有10个数左右，很费解

QinQZ

可以检查下DMA相关的配置和使用了

XMFPGA

QinQZ 发表于 2021-12-27 11:20
可以检查下DMA相关的配置和使用了

麻烦您能帮忙看下具体是哪里的问题吗，感谢大佬！
main.c

1. 
   
2. #include "dma_intr.h"
   
3. #include "timer_intr.h"
   
4. #include "sys_intr.h"
   
5. 
   
6. #include "lwip/err.h"
   
7. #include "lwip/tcp.h"
   
8. #include "lwipopts.h"
   
9. #include "netif/xadapter.h"
   
10. #include "lwipopts.h"
    
11. #include "tcp_transmission.h"
    
12. 
    
13. static  XScuGic Intc; //GIC
    
14. static  XScuTimer Timer;//timer
    
15. XAxiDma AxiDma;
    
16. u32         *RxBufferPtr[2];  /* ping pong buffers*/
    
17. 
    
18. volatile u32 RX_success;
    
19. volatile u32 TX_success;
    
20. 
    
21. volatile u32 RX_ready=1;
    
22. volatile u32 TX_ready=1;
    
23. 
    
24. #define TIMER_LOAD_VALUE    XPAR_CPU_CORTEXA9_0_CPU_CLK_FREQ_HZ / 8 //0.25S
    
25. 
    
26. int init_intr_sys(void)
    
27. {
    
28.         DMA_Intr_Init(&AxiDma,0);//initial interrupt system
    
29.         Timer_init(&Timer,TIMER_LOAD_VALUE,0);
    
30.         Init_Intr_System(&Intc); // initial DMA interrupt system
    
31.         Setup_Intr_Exception(&Intc);
    
32.         DMA_Setup_Intr_System(&Intc,&AxiDma,0,RX_INTR_ID);//setup dma interrpt system
    
33.         Timer_Setup_Intr_System(&Intc,&Timer,TIMER_IRPT_INTR);
    
34.         DMA_Intr_Enable(&Intc,&AxiDma);
    
35. 
    
36. }
    
37. 
    
38. int main(void)
    
39. {
    
40.         int Status;
    
41.         struct netif *netif, server_netif;
    
42.         struct ip_addr ipaddr, netmask, gw;
    
43.         err_t err;
    
44. 
    
45.         /* the mac address of the board. this should be unique per board */
    
46.         unsigned char mac_ethernet_address[] = { 0x00, 0x0a, 0x35, 0x00, 0x01, 0x02 };
    
47. 
    
48.         /* Initialize the ping pong buffers for the data received from axidma */
    
49.         RxBufferPtr[0] = (u32 *)RX_BUFFER0_BASE;
    
50.         RxBufferPtr[1] = (u32 *)RX_BUFFER1_BASE;
    
51. 
    
52.         init_intr_sys();
    
53.         TcpTmrFlag = 0;
    
54. 
    
55.         netif = &server_netif;
    
56. 
    
57.         IP4_ADDR(&ipaddr,  192, 168,   1,  10);
    
58.         IP4_ADDR(&netmask, 255, 255, 255,  0);
    
59.         IP4_ADDR(&gw,      192, 168,   1,  10);
    
60. 
    
61.         /*lwip library init*/
    
62.         lwip_init();
    
63.         /* Add network interface to the netif_list, and set it as default */
    
64.         if (!xemac_add(netif, &ipaddr, &netmask, &gw, mac_ethernet_address, XPAR_XEMACPS_0_BASEADDR)) {
    
65.                 xil_printf("Error adding N/W interface\r\n");
    
66.                 return -1;
    
67.         }
    
68.         netif_set_default(netif);
    
69. 
    
70.         /* specify that the network if is up */
    
71.         netif_set_up(netif);
    
72. 
    
73.         /* initialize tcp pcb */
    
74.         tcp_send_init();
    
75. 
    
76.         Timer_start(&Timer);
    
77. 
    
78. 
    
79.         while (1)
    
80.         {
    
81.                 /* call tcp timer every 250ms */
    
82.                 if(TcpTmrFlag)
    
83.                 {
    
84.                         if(request_pcb->state == CLOSED || (request_pcb->state == SYN_SENT && request_pcb->nrtx == TCP_SYNMAXRTX))
    
85.                         {
    
86.                                 request_pcb = tcp_new();
    
87.                                 if (!request_pcb) {
    
88.                                         xil_printf("txperf: Error creating PCB. Out of Memory\r\n");
    
89.                                         return -1;
    
90.                                 }
    
91. 
    
92.                                 //ip_set_option(request_pcb, SOF_REUSEADDR);
    
93. 
    
94.                                 err = tcp_connect(request_pcb, &ipaddress, port, tcp_connected_callback);
    
95.                                 if (err != ERR_OK) {
    
96.                                         xil_printf("txperf: tcp_connect returned error: %d\r\n", err);
    
97.                                         return err;
    
98.                                 }
    
99.                         }
    
100.                         tcp_tmr();
     
101.                         TcpTmrFlag = 0;
     
102.                 }
     
103.                 /*receive input packet from emac*/
     
104.                 xemacif_input(netif); //将MAC队列里的packets传输到你的LwIP/IP stack里
     
105.                 /* if connected to the server, start receive data from PL through axidma, then transmit the data to the PC software by TCP*/
     
106.                 if(tcp_client_connected)
     
107.                         send_received_data();
     
108.         }
     
109.         return 0;
     
110. 
     
111. }
     

复制代码

dma_intr.h

1. 
   
2. #include "dma_intr.h"
   
3. 
   
4. int DMA_CheckData(int Length, u8 StartValue)
   
5. {
   
6.         u32 *RxPacket;
   
7.         int Index = 0;
   
8.         u32 Value;
   
9. 
   
10.         RxPacket = (u32 *) RX_BUFFER_BASE;
    
11.         Value = StartValue;
    
12. 
    
13.         /* Invalidate the DestBuffer before receiving the data, in case the
    
14.          * Data Cache is enabled
    
15.          */
    
16. #ifndef __aarch64__
    
17.         Xil_DCacheInvalidateRange((u32)RxPacket, Length* sizeof(u32));
    
18. #endif
    
19. 
    
20.         for(Index = 0; Index < Length; Index++) {
    
21.                 if (RxPacket[Index] != Value) {
    
22.                         /*xil_printf("Data error %d: %x/%x\r\n",
    
23.                             Index, RxPacket[Index], Value);*/
    
24. 
    
25.                         return XST_FAILURE;
    
26.                 }
    
27.                 Value = (Value + 1) & 0xFF;
    
28.         }
    
29. 
    
30.         return XST_SUCCESS;
    
31. }
    
32. 
    
33. void DMA_DisableIntrSystem(XScuGic * IntcInstancePtr,
    
34.                                         u16 TxIntrId, u16 RxIntrId)
    
35. {
    
36. #ifdef XPAR_INTC_0_DEVICE_ID
    
37.         /* Disconnect the interrupts for the DMA TX and RX channels */
    
38.         //XIntc_Disconnect(IntcInstancePtr, TxIntrId);
    
39.         XIntc_Disconnect(IntcInstancePtr, RxIntrId);
    
40. #else
    
41.         //XScuGic_Disconnect(IntcInstancePtr, TxIntrId);
    
42.         XScuGic_Disconnect(IntcInstancePtr, RxIntrId);
    
43. #endif
    
44. }
    
45. 
    
46. static void DMA_TxIntrHandler(void *Callback)
    
47. {
    
48. 
    
49.         u32 IrqStatus;
    
50.         int TimeOut;
    
51.         XAxiDma *AxiDmaInst = (XAxiDma *)Callback;
    
52. 
    
53.         /* Read pending interrupts */
    
54.         IrqStatus = XAxiDma_IntrGetIrq(AxiDmaInst, XAXIDMA_DMA_TO_DEVICE);
    
55. 
    
56.         /* Acknowledge pending interrupts */
    
57. 
    
58. 
    
59.         XAxiDma_IntrAckIrq(AxiDmaInst, IrqStatus, XAXIDMA_DMA_TO_DEVICE);
    
60. 
    
61.         /*
    
62.          * If no interrupt is asserted, we do not do anything
    
63.          */
    
64.         if (!(IrqStatus & XAXIDMA_IRQ_ALL_MASK)) {
    
65. 
    
66.                 return;
    
67.         }
    
68. 
    
69.         /*
    
70.          * If error interrupt is asserted, raise error flag, reset the
    
71.          * hardware to recover from the error, and return with no further
    
72.          * processing.
    
73.          */
    
74.         if ((IrqStatus & XAXIDMA_IRQ_ERROR_MASK)) {
    
75.                 xil_printf("rx error! \r\n");
    
76.                 /*
    
77.                  * Reset should never fail for transmit channel
    
78.                  */
    
79.                 XAxiDma_Reset(AxiDmaInst);
    
80. 
    
81.                 TimeOut = RESET_TIMEOUT_COUNTER;
    
82. 
    
83.                 while (TimeOut) {
    
84.                         if (XAxiDma_ResetIsDone(AxiDmaInst)) {
    
85.                                 break;
    
86.                         }
    
87. 
    
88.                         TimeOut -= 1;
    
89.                 }
    
90. 
    
91.                 return;
    
92.         }
    
93. 
    
94.         /*
    
95.          * If Completion interrupt is asserted, then set the TxDone flag
    
96.          */
    
97.         if ((IrqStatus & XAXIDMA_IRQ_IOC_MASK)) {
    
98. 
    
99.                 TxDone = 1;
    
100.         }
     
101. }
     
102. 
     
103. 
     
104. static void DMA_RxIntrHandler(void *Callback)
     
105. {
     
106.         u32 IrqStatus;
     
107.         int TimeOut;
     
108.         XAxiDma *AxiDmaInst = (XAxiDma *)Callback;
     
109. 
     
110.         /* Read pending interrupts */
     
111.         IrqStatus = XAxiDma_IntrGetIrq(AxiDmaInst, XAXIDMA_DEVICE_TO_DMA);
     
112. 
     
113.         /* Acknowledge pending interrupts */
     
114.         XAxiDma_IntrAckIrq(AxiDmaInst, IrqStatus, XAXIDMA_DEVICE_TO_DMA);
     
115. 
     
116.         /*
     
117.          * If no interrupt is asserted, we do not do anything
     
118.          */
     
119.         if (!(IrqStatus & XAXIDMA_IRQ_ALL_MASK)) {
     
120.                 return;
     
121.         }
     
122. 
     
123.         /*
     
124.          * If error interrupt is asserted, raise error flag, reset the
     
125.          * hardware to recover from the error, and return with no further
     
126.          * processing.
     
127.          */
     
128.         if ((IrqStatus & XAXIDMA_IRQ_ERROR_MASK)) {
     
129.                 xil_printf("rx error! \r\n");
     
130.                 return;
     
131.         }
     
132. 
     
133.         /*
     
134.          * If completion interrupt is asserted, then set RxDone flag
     
135.          */
     
136.         if ((IrqStatus & XAXIDMA_IRQ_IOC_MASK)) {
     
137.                 if(packet_trans_done)
     
138.                         xil_printf("last transmission has not finished!\r\n");
     
139.                 else
     
140.                         /*set the axidma done flag*/
     
141.                     packet_trans_done = 1;
     
142.         }
     
143. }
     
144. 
     
145. int DMA_Setup_Intr_System(XScuGic * IntcInstancePtr,XAxiDma * AxiDmaPtr, u16 TxIntrId, u16 RxIntrId)
     
146. {
     
147.         int Status;
     
148.         //XScuGic_SetPriorityTriggerType(IntcInstancePtr, TxIntrId, 0xA0, 0x3);
     
149. 
     
150.         XScuGic_SetPriorityTriggerType(IntcInstancePtr, RxIntrId, 0xA0, 0x3);
     
151.         /*
     
152.          * Connect the device driver handler that will be called when an
     
153.          * interrupt for the device occurs, the handler defined above performs
     
154.          * the specific interrupt processing for the device.
     
155.          */
     
156.         /*
     
157.         Status = XScuGic_Connect(IntcInstancePtr, TxIntrId,
     
158.                                 (Xil_InterruptHandler)DMA_TxIntrHandler,
     
159.                                 AxiDmaPtr);
     
160.         if (Status != XST_SUCCESS) {
     
161.                 return Status;
     
162.         }
     
163. */
     
164.         Status = XScuGic_Connect(IntcInstancePtr, RxIntrId,
     
165.                                 (Xil_InterruptHandler)DMA_RxIntrHandler,
     
166.                                 AxiDmaPtr);
     
167.         if (Status != XST_SUCCESS) {
     
168.                 return Status;
     
169.         }
     
170. 
     
171.         //XScuGic_Enable(IntcInstancePtr, TxIntrId);
     
172.         XScuGic_Enable(IntcInstancePtr, RxIntrId);
     
173.         return XST_SUCCESS;
     
174. }
     
175. 
     
176. 
     
177. 
     
178. int DMA_Intr_Enable(XScuGic * IntcInstancePtr,XAxiDma *DMAPtr)
     
179. {
     
180. 
     
181.         /* Disable all interrupts before setup */
     
182. /*
     
183.         XAxiDma_IntrDisable(DMAPtr, XAXIDMA_IRQ_ALL_MASK,
     
184.                                                 XAXIDMA_DMA_TO_DEVICE);
     
185. */
     
186.         XAxiDma_IntrDisable(DMAPtr, XAXIDMA_IRQ_ALL_MASK,
     
187.                                 XAXIDMA_DEVICE_TO_DMA);
     
188. 
     
189.         /* Enable all interrupts */
     
190. /*
     
191.         XAxiDma_IntrEnable(DMAPtr, XAXIDMA_IRQ_ALL_MASK,
     
192.                                                         XAXIDMA_DMA_TO_DEVICE);
     
193. */
     
194.         XAxiDma_IntrEnable(DMAPtr, XAXIDMA_IRQ_ALL_MASK,
     
195.                                                         XAXIDMA_DEVICE_TO_DMA);
     
196.         return XST_SUCCESS;
     
197. 
     
198. }
     
199. 
     
200. 
     
201. int DMA_Intr_Init(XAxiDma *DMAPtr,u32 DeviceId)
     
202. {
     
203.         int Status;
     
204.         XAxiDma_Config *Config=NULL;
     
205. 
     
206.         Config = XAxiDma_LookupConfig(DeviceId);
     
207.         if (!Config) {
     
208.                 xil_printf("No config found for %d\r\n", DeviceId);
     
209.                 return XST_FAILURE;
     
210.         }
     
211. 
     
212.         /* Initialize DMA engine */
     
213.         Status = XAxiDma_CfgInitialize(DMAPtr, Config);
     
214. 
     
215.         if (Status != XST_SUCCESS) {
     
216.                 xil_printf("Initialization failed %d\r\n", Status);
     
217.                 return XST_FAILURE;
     
218.         }
     
219. 
     
220.         if(XAxiDma_HasSg(DMAPtr)){
     
221.                 xil_printf("Device configured as SG mode \r\n");
     
222.                 return XST_FAILURE;
     
223.         }
     
224.         return XST_SUCCESS;
     
225. 
     
226. }
     

复制代码

QinQZ

我这里有以前调试过的，摄像头经AXI DMA传到PS，经PS网口传给上位机的，可以参考下。因为时间太长，细节忘了
链接：https://pan.baidu.com/s/1XSoABwroFOCo-k4TIXRoDQ
提取码：np42

XMFPGA

QinQZ 发表于 2021-12-27 20:03
我这里有以前调试过的，摄像头经AXI DMA传到PS，经PS网口传给上位机的，可以参考下。因为时间太长，细节忘 ...

十分感谢！