The following functions are supported.

The following code provides a very simple example of how MMFSLib should be used. The code presented here is somewhat simplified and for clarity does not contain any error checking and recovery. It is assumed that the IO devices are accessed via a simple DMA interface; clearly real devices might be more complex than this.

First, a simple routine to stream data from a device to a file for a given duration:

static void write_stream( char *name, int duration )
{
    int i;
    int fd;
    int result;
    void *buffer;
    int bufno = 0;
    int buffer_size;
    mmfs_file_info info;
    cyg_tick_count end;

    // Open the stream for writing.
    fd = mmfs_stream_open( name, MMFS_OPEN_WRITE );

    // Get stream information, we are only interested in the buffer
    // size.
    result = mmfs_stream_info( fd, &info );

    buffer_size = info.buffer_size;

    // Set the stream into streamed write mode. The filesystem in now
    // ready to stream data to this file.
    result = mmfs_stream_set_mode( fd, MMFS_MODE_WRITE, 1 );

    // Convert duration from seconds to an absolute end time in system
    // ticks.
    end = cyg_current_time() + duration*ticks_per_second;

    // Prime the device with the first set of buffers, this will start
    // the DMA transfers going.
    for( i = 0; i < CYGNUM_FS_MMFS_MULTI_BUFFER; i++ )
    {
        result = mmfs_stream_next_buffer( fd, &buffer );

        dma_start( &input, bufno, DMA_READ, buffer, buffer_size );

        bufno++;
        if( bufno >= CYGNUM_FS_MMFS_MULTI_BUFFER ) bufno = 0;
    }

    // Wait for the first buffer to fill.
    dma_wait( &input, bufno );

    // Now stream to the file for the given duration.
    while( cyg_current_time() < end )
    {
        // Fetch a new buffer from MMFS. As a side effect this also
        // invalidates the oldest buffer, which will be the one that
        // has just finished its DMA transfer.
        result = mmfs_stream_next_buffer( fd, &buffer );

        // Set up a DMA transfer from the device
        dma_start( &input, bufno, DMA_READ, buffer, buffer_size );

        bufno++;
        if( bufno >= CYGNUM_FS_MMFS_MULTI_BUFFER ) bufno = 0;

        // Wait for the next device buffer to complete.
        dma_wait( &input, bufno );
    }

    // Wait for remaining buffers to finish
    for( i = 0; i < CYGNUM_FS_MMFS_MULTI_BUFFER; i++ )
    {
        bufno++;
        if( bufno >= CYGNUM_FS_MMFS_MULTI_BUFFER ) bufno = 0;

        dma_wait( &input, bufno );
    }

    // Finally close the stream.
    result = mmfs_stream_close( fd );
}

The code to read a stream is very similar, although this time it is parameterized by the required stride rather than the duration:

static void read_stream( char *name, int stride )
{
    int i;
    int fd;
    int result;
    void *buffer;
    int bufno = 0;
    int buffer_size;
    mmfs_file_info info;

    // Open the stream for reading.
    fd = mmfs_stream_open( name, MMFS_OPEN_READ );

    // Get stream information, we are only interested in the buffer
    // size.
    result = mmfs_stream_info( fd, &info );

    buffer_size = info.buffer_size;

    // Set the stream into streamed read mode using the given
    // stride. The filesystem will start preparation for streaming by
    // prefetching the first data blocks up to the multi-buffer limit.
    result = mmfs_stream_set_mode( fd, MMFS_MODE_READ_FORWARD, stride );

    // Prime the device with the first set of buffers, this will start
    // the DMA transfers going.
    for( i = 0; i < CYGNUM_FS_MMFS_MULTI_BUFFER; i++ )
    {
        result = mmfs_stream_next_buffer( fd, &buffer );

        dma_start( &output, bufno, DMA_WRITE, buffer, buffer_size );

        bufno++;
        if( bufno >= CYGNUM_FS_MMFS_MULTI_BUFFER ) bufno = 0;
    }

    // Wait for the first buffer to empty.
    dma_wait( &input, bufno );

    // Now stream from the file to the device until we reach the end
    // of the file.
    for(;;)
    {
        // Fetch a new buffer full of data from MMFS. As a side effect
        // this also invalidates the oldest buffer, which will be
        // the one that has just finished its DMA transfer.
        result = mmfs_stream_next_buffer( fd, &buffer );
        if( result < 0 && errno == EEOF )
            break;

        // Set up a DMA transfer to the device
        dma_start( &output, bufno, DMA_WRITE, buffer, buffer_size );

        bufno++;
        if( bufno >= CYGNUM_FS_MMFS_MULTI_BUFFER ) bufno = 0;

        // Wait for the next device buffer to complete.
        dma_wait( &output, bufno );
    }

    // Wait for remaining buffers to finish
    for( i = 0; i < CYGNUM_FS_MMFS_MULTI_BUFFER; i++ )
    {
        bufno++;
        if( bufno >= CYGNUM_FS_MMFS_MULTI_BUFFER ) bufno = 0;

        dma_wait( &output, bufno );
    }

    // Finally close the stream.
    result = mmfs_stream_close( fd );
}

The example.c test program contains versions of both of these routines.