ADC to DDR2 using Avalon-ST

You should read the datasheet of sgdma core first. No, there's no full signal as You can transfer only up to 65.5kb of data per descriptor, so You can do the math how many descriptors You'll need to fill the memory. Also remember, that 125MHz Nios system won't be able to work with all the data, as some of Your commands will take more than one cpu instruction.

Thanks for the info Socrates. I've come a long way in the past few days using some example code that you or BadOmen posted. Im still a little hazy on my SOPC/ADC driver design though. Attached is a Jpeg and the driver VHDL code.

#include "io.h"# include "stdio.h"# include "stdlib.h"# include "system.h"# include "alt_types.h"# include "altera_avalon_sgdma.h"# include "altera_avalon_sgdma_regs.h"# include <sys/alt_cache.h># include <sys/stdio.h># include <math.h>
# define NUMBER_OF_BUFFERS 10       /* each direction so double this for the total */# define MINIMUM_BUFFER_LENGTH 50# define MAXIMUM_BUFFER_LENGTH 1500  /* set this to the same value as the min for a fixed size, also don't exceed 65535 */
volatile alt_u8 rx_done = 0;
alt_sgdma_dev *DEVICE;
alt_sgdma_descriptor *dma_descriptors, *dma_descriptors_copy;
void dma_interrupt(void * context) {
    rx_done=1;  /* main will be polling for this value being 1 */
}
alt_u8 allocate_descriptors(alt_sgdma_descriptor **dma_descriptors,
                                                        alt_sgdma_descriptor **dma_descriptors_copy,
                                                        alt_u32 num_buffers)
{
        void *temp_pointer;
        temp_pointer = malloc((num_buffers + 2) * ALTERA_AVALON_SGDMA_DESCRIPTOR_SIZE);
        if(temp_pointer==NULL) return 1;
    *dma_descriptors_copy = (alt_sgdma_descriptor *)temp_pointer;
    while((((alt_u32)temp_pointer) % ALTERA_AVALON_SGDMA_DESCRIPTOR_SIZE) != 0) temp_pointer++;  // Limit size @ 32 bytes
    *dma_descriptors = (alt_sgdma_descriptor *)temp_pointer;
    dma_descriptors->control = 0; // Set IE_ERROR=0 bit in control register
    return 0;
}
alt_u8 allocate_dma_buffers(alt_sgdma_descriptor *dma_descriptors, alt_u32 num_buffers) {
        alt_u32 i, length = 0;
        alt_u32 *data_pointer;
        for(i=0; i<num_buffers; i++){
                length = MINIMUM_BUFFER_LENGTH;
                data_pointer = (alt_u32 *)malloc(length);
                if(data_pointer == NULL) return 1;
        alt_avalon_sgdma_construct_stream_to_mem_desc(&dma_descriptors,  // descriptor
                                                      &dma_descriptors, // next descriptor
                                                      data_pointer,  // write buffer location
                                                      MINIMUM_BUFFER_LENGTH,  //(alt_u16)length,  // I will wait for End Of Packet instead of fixed length
                                                      0); // writes are not to a fixed location
        }
    alt_dcache_flush_all();
    return 0;
}
/* Making sure that there will be enough space for code (maximum of 1.5MB) */
int main(){
    alt_putstr("Here");
    alt_u8 returned = 0;
    DEVICE = alt_avalon_sgdma_open("/dev/sgdma_0");
    if(DEVICE == NULL)
    {
        alt_putstr("Could Not Find SGDMA Device");
        return 1;
    }
    else
    {
        alt_putstr("Found SGDMA Device");
    }
    IOWR_ALTERA_AVALON_SGDMA_CONTROL(DEVICE->base,ALTERA_AVALON_SGDMA_CONTROL_SOFTWARERESET_MSK); // Reset SGDMA
    IOWR_ALTERA_AVALON_SGDMA_CONTROL(DEVICE->base,0x0);
    IOWR_ALTERA_AVALON_SGDMA_CONTROL(DEVICE->base, ALTERA_AVALON_SGDMA_CONTROL_PARK_MSK); // change park
    returned = allocate_descriptors(&dma_descriptors, &dma_descriptors_copy, NUMBER_OF_BUFFERS);
    if(returned) alt_putstr("### ERROR: Failed to allocate memory for descriptors!\n");
    returned = allocate_dma_buffers(dma_descriptors,NUMBER_OF_BUFFERS);                                                       // Allocate data buffers and construct descriptors
    if(returned) alt_putstr("### ERROR: Failed to allocate memory for data receive!\n");
    alt_avalon_sgdma_register_callback(DEVICE, &dma_interrupt,
        (ALTERA_AVALON_SGDMA_CONTROL_IE_GLOBAL_MSK | ALTERA_AVALON_SGDMA_CONTROL_IE_CHAIN_COMPLETED_MSK),
                                           NULL);
    //printf("%d", sizeof(alt_sgdma_descriptor));
    // last descriptor needs to point to the first
    dma_descriptors.next = (alt_sgdma_descriptor *)dma_descriptors;
    printf("descriptor address: %d  \n", dma_descriptors);
    printf("final descriptor next: %d   \n", dma_descriptors.next);
    if(alt_avalon_sgdma_do_async_transfer(DEVICE, &dma_descriptors) != 0)
                        alt_putstr("FAIL! (Writing the head of the descriptor list to the DMA failed)\n");
    int i = 0;
    int j = 0;
    for( i = 0; i < 10; i++)
    {
        if(alt_avalon_sgdma_do_async_transfer(DEVICE, &dma_descriptors) != 0)
                                alt_putstr("FAIL! (Writing the head of the descriptor list to the DMA failed)\n");
        usleep(5000);
        int k = 0;
        /// problem area
        for(j = 0; j < NUMBER_OF_BUFFERS; j++)
        {
            printf("%d   ", IORD_32DIRECT((&dma_descriptors.write_addr),0));
            //alt_putstr(&dma_descriptors.write_addr);
            dma_descriptors.control = dma_descriptors.control | ALTERA_AVALON_SGDMA_DESCRIPTOR_CONTROL_OWNED_BY_HW_MSK;
        }
//        int k = 0;
//        for(k = 0; k < NUMBER_OF_BUFFERS; k ++)
//        {
//            dma_descriptors.control = dma_descriptors.control | 0b10000001;
//        }
    }
//
//    alt_putstr(">>> Starting SGDMA transfers... \n");
//
//    if(alt_avalon_sgdma_do_async_transfer(DEVICE, &dma_descriptors) != 0)
//            alt_putstr("FAIL! (Writing the head of the descriptor list to the DMA failed)\n");
//
////    while(rx_done == 0) {
////        alt_putstr("Something\n");
////        usleep(5000);
////    }
//
//
//    usleep(500000);
//
//    //alt_putstr(">>> The SGDMA transfer has completed, Done = %u\n",(unsigned int)rx_done);
//
//
//
//
//
//    alt_avalon_sgdma_stop(DEVICE);
//    //free(dma_descriptors_copy);
//    //free(dma_descriptors);
//
//    // do stuff to transfer the data off
//
//    alt_putstr(" dumping data ");
//    alt_u32 *data_pointer;
//    int i = 0;
//    for(i = 0; i < NUMBER_OF_BUFFERS; i++)
//    {
//        data_pointer = dma_descriptors.write_addr;
//        alt_putstr(&data_pointer);
//    }
    //free(dma_descriptors_copy);
    //free(dma_descriptors);
    //alt_putstr("Working...\n");
    return 0;
}

Hi, mwb500 :

Do a proper debug.