int alt_epcs_flash_init(alt_flash_epcs_dev* flash);

struct alt_flash_epcs_dev
{
  alt_flash_dev dev;

  alt_u32 register_base;
  alt_u32 size_in_bytes;
  alt_u32 silicon_id;
  alt_u32 page_size;
};
// и тут же далее по ссылке  alt_flash_dev
struct alt_flash_dev
{
  alt_llist                 llist;
  const char*               name;
  alt_flash_open            open;
  alt_flash_close           close;
  alt_flash_write           write;
  alt_flash_read            read;
  alt_flash_get_flash_info  get_info;
  alt_flash_erase_block     erase_block;
  alt_flash_write_block     write_block;
  void*                     base_addr;
  int                       length;
  int                       number_of_regions;
  flash_region              region_info[ALT_MAX_NUMBER_OF_FLASH_REGIONS];
};

//включаю файлы заголовков
#define ALT_USE_EPCS_FLASH
#include <altera_avalon_epcs_flash_controller.h>
alt_flash_epcs_dev mem;
int a;
//задаю название контролерра
mem.dev.name=EPCS_FLASH_CONTROLLER_0_NAME;
// пытаюсь инициализировать его
a = alt_epcs_flash_init(mem);
// и прочитать
ret_code = alt_epcs_flash_read(mem->dev, 0, data_array_name, 16);

ret_code = alt_epcs_flash_read(mem.dev, 0, data_array_name, 16);

#include "system.h"
#include "altera_avalon_pio_regs.h"
#include "alt_types.h"
#include "epcs_commands.h"

int main (void)
{ alt_flash_fd* fd;

  alt_u8 epcs_status;

  epcs_status = epcs_read_status_register(EPCS_FLASH_CONTROLLER_BASE);

  fd = alt_flash_open_dev("/dev/epcs_flash_controller");
  if(fd != NULL)
    { IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE, 0x01);
      alt_flash_close_dev(fd);
    }
  else { IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE, 0x55);
       }

  while (1)
  ;
}

#define EPCS_ADR 523776

alt_u8 data[15];
alt_u32 j;

    j = epcs_read_buffer(EPCS_FLASH_BASE+EPCS_FLASH_REGISTER_OFFSET, EPCS_ADR, &data, 15);

    for(i=0;i<15;i++)
    {
        printf("%x\n",data[i]);
    }


    data[0]=0x00;
    data[1]=0x01;
    data[2]=0x02;
    data[3]=0x03;
    data[4]=0x04;
    data[5]=0x05;
    data[6]=0x06;
    data[7]=0x10;
    data[8]=0x20;
    data[9]=0x30;
    data[10]=0x40;
    data[11]=0x50;
    data[12]=0x6C;
    data[13]=0xAA;
    data[14]=0xFF;


    j = epcs_write_buffer(EPCS_FLASH_BASE+EPCS_FLASH_REGISTER_OFFSET, EPCS_ADR , &data, 15);

    j = epcs_read_buffer(EPCS_FLASH_BASE+EPCS_FLASH_REGISTER_OFFSET, EPCS_ADR, &data, 15);

    for(i=0;i<15;i++)
    {
        printf("%x\n",data[i]);
    }

...
unsigned char e_buf[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
...
epcs_write_enable(EPCS_FLASH_CONTROLLER_0_BASE+EPCS_FLASH_CONTROLLER_0_REGISTER_
OFFSET);
epcs_sector_erase(EPCS_FLASH_CONTROLLER_0_BASE+EPCS_FLASH_CONTROLLER_0_REGISTER_
OFFSET,EPCS_SET_OFFS);
epcs_read_buffer(EPCS_FLASH_CONTROLLER_0_BASE+EPCS_FLASH_CONTROLLER_0_REGISTER_O
FFSET,EPCS_SET_OFFS,e_buf,16);
for(t=0;t<16;t++)
alt_printf("e_buf[%x]=%x\n",t,e_buf[t]);
for(t=0;t<16;t++)
e_buf[t] = t;
epcs_write_buffer(EPCS_FLASH_CONTROLLER_0_BASE+EPCS_FLASH_CONTROLLER_0_REGISTER_
OFFSET,EPCS_SET_OFFS,e_buf,16);
for(t=0;t<16;t++)
alt_printf("e_buf[%x]=%x\n",t,e_buf[t]);
for(t=0;t<16;t++)
e_buf[t]=0;
for(t=0;t<16;t++)
alt_printf("e_buf[%x]=%x\n",t,e_buf[t]);
epcs_read_buffer(EPCS_FLASH_CONTROLLER_0_BASE+EPCS_FLASH_CONTROLLER_0_REGISTER_O
FFSET,EPCS_SET_OFFS,e_buf,16);
for(t=0;t<16;t++)
alt_printf("e_buf[%x]=%x\n",t,e_buf[t]);

e_buf[0]=ff
e_buf[1]=ff
e_buf[2]=ff
e_buf[3]=ff
e_buf[4]=ff
e_buf[5]=ff
e_buf[6]=ff
e_buf[7]=ff
e_buf[8]=ff
e_buf[9]=ff
e_buf[a]=ff
e_buf[b]=ff
e_buf[c]=ff
e_buf[d]=ff
e_buf[e]=ff
e_buf[f]=ff
e_buf[0]=0
e_buf[1]=1
e_buf[2]=2
e_buf[3]=3
e_buf[4]=4
e_buf[5]=5
e_buf[6]=6
e_buf[7]=7
e_buf[8]=8
e_buf[9]=9
e_buf[a]=a
e_buf[b]=b
e_buf[c]=c
e_buf[d]=d
e_buf[e]=e
e_buf[f]=f
e_buf[0]=0
e_buf[1]=0
e_buf[2]=0
e_buf[3]=0
e_buf[4]=0
e_buf[5]=0
e_buf[6]=0
e_buf[7]=0
e_buf[8]=0
e_buf[9]=0
e_buf[a]=0
e_buf[b]=0
e_buf[c]=0
e_buf[d]=0
e_buf[e]=0
e_buf[f]=0
e_buf[0]=0
e_buf[1]=1
e_buf[2]=2
e_buf[3]=3
e_buf[4]=4
e_buf[5]=5
e_buf[6]=6
e_buf[7]=7
e_buf[8]=8
e_buf[9]=9
e_buf[a]=a
e_buf[b]=b
e_buf[c]=c
e_buf[d]=d
e_buf[e]=e
e_buf[f]=f

alt_32 epcs_read_buffer(alt_u32 base, int offset, alt_u8 *dest_addr, int length)
{
alt_u8 read_command[4];

read_command[0] = epcs_read;
read_command[1] = (offset >> 16) & 0xFF;
read_command[2] = (offset >> 8) & 0xFF;
read_command[3] = offset & 0xFF;

#if 0
/* If a write is in progress, fail. */
if (epcs_test_wip(base))
return 0;
#endif
/* I don't know why this is necessary, since I call await-wip after
* all writing commands.
*/
epcs_await_wip_released(base);

alt_avalon_spi_command(
base,
0,
sizeof(read_command) / sizeof(*read_command),
read_command,
length,
(alt_u8*)dest_addr,
0
);

return length;
}

  epcs_await_wip_released(base);

void wright_data_to_epcs()
{
    epcs_write_enable(EPCS_FLASH_BASE+EPCS_FLASH_REGISTER_OFFSET);
    epcs_sector_erase(EPCS_FLASH_BASE+EPCS_FLASH_REGISTER_OFFSET, EPCS_ADR);
    j = epcs_write_buffer(EPCS_FLASH_BASE+EPCS_FLASH_REGISTER_OFFSET, EPCS_ADR , data, DATA_EPCS_SIZE);
    return;
}

#include "epcs_commands.h"

// адрес EPCS контроллера
const alt_u32 EPCS_ADDR = EPCS_FLASH_CONTROLLER_0_BASE + EPCS_FLASH_CONTROLLER_0_REGISTER_OFFSET;
// смещение параметров модуля в EPCS - 30 страница для хранения
const alt_u32 EPCS_PARAMS_OFFSET = 65536*30;
// режим байтов для EPCS
const alt_u32 EPCS_BYTE_MODE = 0;

void LoadEpcsData(alt_u8* destBuf, int length)
{
    epcs_read_buffer(EPCS_ADDR, EPCS_PARAMS_OFFSET, destBuf, length, EPCS_BYTE_MODE);
}

void SaveEpcsData(alt_u8* srcBuf, int length)
{
    epcs_write_enable(EPCS_ADDR);
    epcs_sector_erase(EPCS_ADDR, EPCS_PARAMS_OFFSET, EPCS_BYTE_MODE);
    epcs_write_buffer(EPCS_ADDR, EPCS_PARAMS_OFFSET, srcBuf, length, EPCS_BYTE_MODE);
}