#include "epcs_commands.h"


unsigned char * epcs_dst;
unsigned int epcs_buff[4];
epcs_dst = &epcs_buff[0];
fprintf(stdout, "\nepcs id = %x", epcs_read_device_id(EPCS_FLASH_CONTROLLER_BASE + EPCS_FLASH_CONTROLLER_REGISTER_OFFSET));
epcs_read_buffer(EPCS_FLASH_CONTROLLER_BASE, 65536*127, epcs_dst, 16);
    fprintf(stdout, "\n1 = %x", epcs_buff[0]);

fprintf(stdout, "\nepcs id = %x", epcs_read_device_id(EPCS_FLASH_CONTROLLER_BASE));

epcs_write_enable(EPCS_FLASH_CONTROLLER_BASE + EPCS_FLASH_CONTROLLER_REGISTER_OFFSET);
epcs_sector_erase(EPCS_FLASH_CONTROLLER_BASE + EPCS_FLASH_CONTROLLER_REGISTER_OFFSET, 127);
res = epcs_write_buffer(EPCS_FLASH_CONTROLLER_BASE + EPCS_FLASH_CONTROLLER_REGISTER_OFFSET, 65536*127, epcs_src, 16);

alt_u8 epcs_read_device_id(alt_u32 base);
alt_u8 epcs_read_electronic_signature(alt_u32 base);
alt_u8 epcs_read_status_register(alt_u32 base);
void epcs_sector_erase(alt_u32 base, alt_u32 offset);
alt_32 epcs_read_buffer(alt_u32 base, int offset, alt_u8 *dest_addr, int length);
void epcs_write_enable(alt_u32 base);
void epcs_write_status_register(alt_u32 base, alt_u8 value);
alt_32 epcs_write_buffer(alt_u32 base, int offset, const alt_u8 *src_addr, int length);

    alt_flash_fd    *p_epcs_fd;
    flash_region    *p_epcs_reg_info;
    int             num_epcs_regs;
    unsigned int epcs_buff[4];

    p_epcs_fd = alt_flash_open_dev("/dev/epcs_flash_controller");
    alt_epcs_flash_get_info(p_epcs_fd, &(p_epcs_reg_info), &(num_epcs_regs));
    alt_epcs_flash_read(p_epcs_fd, 65536*126, (void*)epcs_buff, 16);
    alt_flash_close_dev(p_epcs_fd);

    p_epcs_fd = alt_flash_open_dev("/dev/epcs_flash_controller");
    alt_epcs_flash_erase_block(p_epcs_fd, 126);
    alt_epcs_flash_write_block(p_epcs_fd, 126, 0, (void*)epcs_buff, 16);
    alt_flash_close_dev(p_epcs_fd);

void    RdEPCS_Set()
{
    epcs_read_buffer(EPCS_CONTROLLER_BASE+EPCS_CONTROLLER_REGISTER_OFFSET,
    EPCS_SET_OFFS, EPCS_buffer, EPCS_BUF_SIZE);
}
//---------------------------------------------------------------------------------------------
void    WrEPCS_Set()
{
    epcs_sector_erase(EPCS_CONTROLLER_BASE+EPCS_CONTROLLER_REGISTER_OFFSET,EPCS_SET_OFFS);
    epcs_write_buffer(EPCS_CONTROLLER_BASE+EPCS_CONTROLLER_REGISTER_OFFSET,
                              EPCS_SET_OFFS, EPCS_buffer, EPCS_BUF_SIZE);
}

#define ALT_USE_EPCS_FLASH
#include "altera_avalon_epcs_flash_controller.h"

alt_flash_fd    *fd;
unsigned int epcs_buff[4];
fd = alt_flash_open_dev("/dev/epcs_flash_controller");
if (fd != NULL) {
    printf ("\nopen OK");
    alt_epcs_flash_read(fd, 65536*126, (void*)epcs_buff, 16);
}
alt_flash_close_dev(fd);

fd = alt_flash_open_dev("/dev/epcs_flash_controller");
if (fd != NULL) {
   alt_epcs_flash_erase_block(fd, 126);
   alt_epcs_flash_write_block(fd, 0, 65536*126, (void*)epcs_buff, 16);
}
alt_flash_close_dev(fd);

/* Write, assuming that someone has kindly erased the appropriate
* sector(s).
* Note: "block_offset" is the base of the current erase block.
* "data_offset" is the absolute address (from the 0-base of this
* device's memory) of the beginning of the write-destination.
* This device has no need for "block_offset", but it's included for
* function type compatibility.
*/
int alt_epcs_flash_write_block

а вариант, что я выше предлагал чем не нравится? памяти, кстати, меньше будет жрать. и с reduced device drivers будет работать

alt_epcs_flash_erase_block(fd, 126)

alt_epcs_flash_write(fd, 65536*126, (void*)epcs_buff, 16);

epcs_sector_erase(EPCS_FLASH_CONTROLLER_BASE+EPCS_FLASH_CONTROLLER_REGISTER_OFFSET, 65536*126);
epcs_write_buffer(    EPCS_FLASH_CONTROLLER_BASE+EPCS_FLASH_CONTROLLER_REGISTER_OFFSET, 65536*126,
        (void*)epcs_buff, 16);

epcs_read_buffer(EPCS_FLASH_CONTROLLER_BASE+EPCS_FLASH_CONTROLLER_REGISTER_OFFSET, 65536*126, (void*)epcs_buff, 16);

unsigned char e_buf[16];
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