I am having two problems with the sg-dma in my system. My first issue is that the sg-dma ready signal goes low after the first element of streaming data, then returns high on the third. This causes the second element to be skipped. I am streaming data at the same rate as the sg-dma clock. My second issue is that I can not re-use the descriptors. I try to set the hardware owned bit to 1 by the following command: DMA_desc[0].control=128; The sg-dma ready signal goes high when I call the do_async_transfer() function, but it toggles low when it gets streaming data. No data is transferred to memory. Can anyone help?? Thanks.

--- Quote Start --- I am having two problems with the sg-dma in my system. My first issue is that the sg-dma ready signal goes low after the first element of streaming data, then returns high on the third. This causes the second element to be skipped. I am streaming data at the same rate as the sg-dma clock. --- Quote End --- It sounds like the components that are the source of the stream aren't prepared to accept the backpressure from the SGDMA. It's only going to get worse if the SGDMA encounters any contention or other delays (e.g. SDRAM refresh) when it's trying to burst to the memory. One workaround is you can place an Avalon-ST FIFO right before the SGDMA; the FIFO won't deassert 'ready' until it is nearly full.

The solution to the ready signal going low after the first piece of data was to put the sgdma in burst mode. The solution to the second problem was to build the descriptors again. My new problem is that the descriptors are not built in a timely fashion for my system. I would like to use the PARK option in the control register map, so I can re-use the descriptor without rebuilding it. I have not had any success programming this configuration. Does anyone have some CODE that can show a working system that re-uses the descriptors? Thank you in advance for your help!

Using the park mode is tricky because if you are not careful you may end up with a race condition when switching to another descriptor list. I don't have an example of it but if you look at the example designs for the NEEK that use the LCD you will see the video framebuffering getting parked so that the same frame can be re-used. Essentially the way it works is you create a linked list that loops back on itself and by setting the park bit the SGDMA doesn't flip the owned by hardware bit low when it consumes the descriptors. Due to that and the descriptor linked list loopback the SGDMA hits the end of the list, loops back to the start, and reuses the descriptors. If you want to see a simpler implementation take a look at the DMA engine that I posted to the wiki: http://www.alterawiki.com/wiki/modular_sgdma Parking is a simple as turning on a bit in a descriptor so that the engine keeps using it until you provide a new descriptor. You also don't need to chain a bunch of descriptors together to get a large transfer size, this DMA engine can move up to 4GB if you setup the hardware accordingly. An example of how to use the feature for video buffering purposes is shown here: http://www.alterawiki.com/wiki/modular_sgdma_video_frame_buffer

I have some working code that continuously takes in serial data to on-chip ram from 2 stream-to-memory sgdma's, and puts the serial data in a circular buffer in ddr memory. The code puts the two stream-to-memory sgdma's in park mode, and the descriptor points back to itself for continuous operation. A call back is registered for the completion of each stream-to-memory descriptor to start the data transfer to the ddr3 circular buffer. The ddr3 transfer is done with a memory-to-memory sgdma with and single descriptor chain. The descriptor chain is rebuilt after each transfer. Comments are more than welcome... // CWstream1_DMA SGDMA callback function // * After each descriptor is processed (1600 bytes), the data is transfered to DDR3 memory in a circular buffer void CWstream1_callback_function(void * context) { // tx tells the circular buffer which sgdma was processed tx=0; alt_avalon_sgdma_do_async_transfer(DDR3_DMA, &DDR3_DMA_desc[0]); } // CWstream2_DMA SGDMA callback function // * After each descriptor is processed (1600 bytes), the data is transfered to DDR3 memory in a circular buffer void CWstream2_callback_function(void * context) { IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE, 1); // tx tells the circular buffer which sgdma was processed tx=1; alt_avalon_sgdma_do_async_transfer(DDR3_DMA, &DDR3_DMA_desc[0]); } // DDR3_DMA callback function // * Re-initialize the descriptor for the next memory transfer // * Check the memory position to see if the circular buffer needs to start over void DDR3_callback_function(void * context) { // update the write address of the circular buffer write_addr = write_addr + 0x640; if (write_addr >= 0x3e80) { DDR3_write_addr = DDR3_BASE; write_addr = 0; } else DDR3_write_addr = DDR3_BASE + write_addr; // Check which sgdma was processed so we can know where to read the data from if (tx == 1) { alt_avalon_sgdma_construct_mem_to_mem_desc(&DDR3_DMA_desc[0], &DDR3_DMA_desc[1], CW_DAQ1_write_addr, DDR3_write_addr, 1600, 0, 0); IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE, 3); IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE, 4); } else { alt_avalon_sgdma_construct_mem_to_mem_desc(&DDR3_DMA_desc[0], &DDR3_DMA_desc[1], CW_DAQ2_write_addr, DDR3_write_addr, 1600, 0, 0); IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE, 2); } DDR3_DMA_desc[0].control=128; DDR3_DMA_desc[1].control=0; } // Main code entry // * Write a message to the LCD display for fun // * Initialize pushbutton callbacks // * Clear memory space // * Start DMA engines // * Sit in a while loop and wait for callbacks int main(void) { // Initialize circular DDR3 transfer variables write_addr = 0; // This is a software reset to the ping-pong selector hardware counter. // Pull this low and then return to the high state will reset the counter to 0. IOWR_ALTERA_AVALON_PIO_DATA(PIO_PROGRAM_BASE, 0); // Reset the sgdma controller // This is a software reset, - not sure if needed // The documentation states this is a last resort control, so we should remove this if we can. // Embedded Peripherals IP User Guide, pg 25-12 IOWR_32DIRECT(SGDMA_ST1_BASE, 16, 0x10000); IOWR_32DIRECT(SGDMA_ST2_BASE, 16, 0x10000); usleep(1000); IOWR_32DIRECT(SGDMA_ST1_BASE, 16, 0x10000); IOWR_32DIRECT(SGDMA_ST2_BASE, 16, 0x10000); usleep(1000); // Open the CW streaming scatter-gather DMA controllers CWstream_DMA1 = alt_avalon_sgdma_open("/dev/sgdma_st1"); if(CWstream_DMA1 == NULL) printf("Could not open the CW SG-DMA1\n"); CWstream_DMA2 = alt_avalon_sgdma_open("/dev/sgdma_st2"); if(CWstream_DMA2 == NULL) printf("Could not open the CW SG-DMA2\n"); // Open the Memory transfer to circular buffer scatter-gather DMA controller DDR3_DMA = alt_avalon_sgdma_open("/dev/sgdma_ddr3"); if(DDR3_DMA == NULL) printf("Could not open the DDR3 SG-DMA\n"); // Set the write addresses for data transfers CW_DAQ1_write_addr = (alt_u32 *)(DAQ1_MEM_BASE); CW_DAQ2_write_addr = (alt_u32 *)(DAQ2_MEM_BASE); DDR3_write_addr = (alt_u32 *)(DDR3_BASE); // Set up the CW stream 1 descriptor // The descriptor points back to itself for continuous operation // The PARK bit of the control register must be set in order to re-use the descriptor (done in the callback registration)r alt_avalon_sgdma_construct_stream_to_mem_desc(&CWstream_DMA1_desc[0], &CWstream_DMA1_desc[0], CW_DAQ1_write_addr, 1600, 0); // Set the OWNED_BY_HW bit to 1 on desc[0] CWstream_DMA1_desc[0].control=128; // Set up the CW stream 2 descriptor alt_avalon_sgdma_construct_stream_to_mem_desc(&CWstream_DMA2_desc[0], &CWstream_DMA2_desc[0], CW_DAQ2_write_addr, 1600, 0); CWstream_DMA2_desc[0].control=128; // Set up DDR3 1 descriptor alt_avalon_sgdma_construct_mem_to_mem_desc(&DDR3_DMA_desc[0], &DDR3_DMA_desc[1], CW_DAQ1_write_addr, DDR3_write_addr, 1600, 0, 0); // Set the OWNED_BY_HW bit to 1 on desc[0], and set the bit to 0 on desc[1] // This stops the descriptor chain at desc[1] and flags an interrupt for its callback function DDR3_DMA_desc[0].control=128; DDR3_DMA_desc[1].control=0; // Register callback functions // CWstream1 callback // The PARK_MASK allows prevent the OWNED_BY_HW bit from being cleared after the descriptor is processed alt_avalon_sgdma_register_callback(CWstream_DMA1, &CWstream1_callback_function, (ALTERA_AVALON_SGDMA_CONTROL_IE_GLOBAL_MSK | ALTERA_AVALON_SGDMA_CONTROL_PARK_MSK | ALTERA_AVALON_SGDMA_CONTROL_IE_DESC_COMPLETED_MSK | ALTERA_AVALON_SGDMA_CONTROL_IE_CHAIN_COMPLETED_MSK ), NULL); // CWstream2 callback alt_avalon_sgdma_register_callback(CWstream_DMA2, &CWstream2_callback_function, (ALTERA_AVALON_SGDMA_CONTROL_IE_GLOBAL_MSK | ALTERA_AVALON_SGDMA_CONTROL_PARK_MSK | ALTERA_AVALON_SGDMA_CONTROL_IE_DESC_COMPLETED_MSK | ALTERA_AVALON_SGDMA_CONTROL_IE_CHAIN_COMPLETED_MSK), NULL); //DDR3 callback alt_avalon_sgdma_register_callback(DDR3_DMA, &DDR3_callback_function, (ALTERA_AVALON_SGDMA_CONTROL_IE_GLOBAL_MSK | ALTERA_AVALON_SGDMA_CONTROL_IE_CHAIN_COMPLETED_MSK), NULL); usleep(1000); IOWR_ALTERA_AVALON_PIO_DATA(PIO_PROGRAM_BASE, 1); // Start the CW transfers alt_avalon_sgdma_do_async_transfer(CWstream_DMA1, &CWstream_DMA1_desc[0]); alt_avalon_sgdma_do_async_transfer(CWstream_DMA2, &CWstream_DMA2_desc[0]); // Sit in a while loop while callbacks happen while (1) { } // Should not reach this code printf("\nExit\n\n"); return 0; }

You might be exposed to a race condition, it really depends on how many descriptors are in the chain and how fast the CPU can maintain control over the SGDMA. The problem with circular buffering like this is if the processor gets bogged down, it's possible that the SGDMA ends up overwriting data that your CPU is not done using. What you describing sounds like it would be more appropriate to implement using ping pong buffering where one buffer is being filled while the other one is being consumed by the processor or whatever uses the data afterwards. With ping pong buffering you could just have two linked lists, one per buffer, and each time the SGDMA hits the end of the list you just point it over to the other list and start it back up.

Stream to Memory sgdma problem | Altera Community

22 Replies

Altera_Forum
Honored Contributor
12 years ago
Could you describe what was the problem and how you solved it, so that others facing the same problem can find a solution?
Altera_Forum
Honored Contributor
12 years ago
I build some simple Stream to Memory in 3Mhz then forward to Stream out in 150Mhz, continuously... (DC-FIFO -> SGDMA -> Memory -> SGDMA)
But, I do some debug with "printf" command and became stuck (looks in Nios Console).
When I change debug into PIO to drive LEDs, it was runs...
I assumed, "printf" tho show debug process in Nios console can't follow interrupt request from SGDMA (in high speed interrupt)
Altera_Forum
Honored Contributor
12 years ago
The printf() function is probably using interruption itself to write to the JTAG UART, so you can't call it from an ISR or a DMA transfer callback function. If this is what you are doing then it could explain why the system hangs.
Altera_Forum
Honored Contributor
11 years ago
Yes.. I'm agree with you Daixiwen..
Then I use LED PIO to trace the state for debugging purpose..
Thank you..
Altera_Forum
Honored Contributor
11 years ago
In general I would avoid putting any time consuming code into an ISR. While the processor is in the ISR it can't handle other interrupts or other tasks so you typcially want to keep the amount of work done inside an ISR to a minimum. If you overload an ISR with work it can lead to problems that are hard to predict or reproduce for debug purposes.
Altera_Forum
Honored Contributor
11 years ago
Hello Guys, I have a problem with SGDMA which occurred recently. I am using SGDMA Module for almost 4 years (Thanks to BadOmen)and so far it worked very well without any problems. recently, we have an application which requires higher data transfer and I used ST-MM SGDMA to write data from ADCs to SDRAM. I did a test for 25 GB of data and it is all ok except 16KB of data. looks like in that particular 16KB, 4th byte is always written zero and after that 16KB it is all ok. this only happens once during that 25GB of data. I have 3 different SGDMAs and the other 2 are ok. the Transfer size is programmed to (16777216 Bytes) and I am transferring the amount of 5191560 Bytes each time. I ma using Packet support and ready latency of 1. I know this problem is looks vague but any idea and comment on that greatly apprecited. Many thanks,
Aidin.
Altera_Forum
Honored Contributor
11 years ago
forgot mentioning that the data width is 8 bit.
Altera_Forum
Honored Contributor
11 years ago
My suggestion would be to try to capture the event on SignalTap in order to gain better understanding of where the issue is.
Tap signals on:
- SDRAM slave port
- SGDMA master port
- SGDMA Avalon-ST sink (from ADC)

and figure out at which stage the 00's are getting introduced.

If 00's are never on the Avalon-ST and is reliably there on the SGDMA Avalon-MM Master port, then yes it sounds like a bug in the SGDMA and you would need to dig inside it a bit further.
Altera_Forum
Honored Contributor
11 years ago
If you haven't updated the IP I highly recommend it because I fixed a bug a year or two ago which caused FIFO corruption under some configurations. I forget what configurations are affected but the symptom was that the FIFO inside one of the masters would transistion from empty to full and vice versa which would cause data to be lost or garbage to be written.

The IP is available in Qsys as of 14.0 so if you are using that version I recommend using it instead. Unfortunately the driver isn't available yet so you would have to continue using the old driver.

Also if you want to maximize memory bandwidth I recommend making the DMA wider and using a data format adapter to convert the 8-bit data from the ADC to a wider beat so that the DMA can use more of the memory bandwidth each clock cycle (I'm assuming your RAM isn't 8-bit)
Altera_Forum
Honored Contributor
11 years ago
Thanks guys for valuable comments. YES, it was indeed the problem. updated SGDMA and also put adaptor and it fixed the issue. Badomen, our RAM is 16 bit but because of the some complexity issues we have decided to keep that side 8 bit. however, I widened the SGDMA and put an adaptor. Thanks again guys.

Forum Discussion

Stream to Memory sgdma problem

22 Replies

Recent Discussions

Agilex3/5 GTS Hard Ethernet IP 10G example design pin loc and io std wanted

Agilex 7 slew rate reconfiguration

Agilex-7 AXI MCDMA for PCIe hang

Constraints not being picked for DCFIFO

Can't generate F-Tile Ethernet Hard IP Design Example