linux 用户空间gpio加载FPGA

实际项目中的代码，加载速度有点慢，但功能实现。

fpga.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdint.h>
#include <getopt.h>


#include "fpga.h"
#include "gpio.h"




static const char *nCONFIG= "/sys/class/gpio/gpio494/value";
static const char *nSTATUS= "/sys/class/gpio/gpio495/value";
static const char *DATA = "/sys/class/gpio/gpio490/value";
static const char *CLK = "/sys/class/gpio/gpio486/value";
static const char *CONF_DONE= "/sys/class/gpio/gpio487/value";
static const char *FPGA_DAT= "/ffs/fpga.rbf";




uint8_t nconfig_fd,nstatus_fd,data_fd,clk_fd,conf_done_fd,fpga_dat_fd;
//int fpga_fd;


static void fpgadelay(UINT32 ms)
{
//usleep(ms);
while(ms--);// 3条指令
}


UINT StartConfig(void) //BOOL StartConfig(void)
{
int ret;
UINT DELAYDO;
volatile unsigned long ulLoop;
volatile UCHAR val;

/*nConfig(PE10) = 0*/
//CLR_BIT(GPIOE_PDOR,nCONFIG_MASK);
lseek(nconfig_fd, 0, SEEK_SET);
gpio_write_b(nconfig_fd, 0);


#if 0
for(ulLoop = 0; ulLoop < (490000*2); ulLoop++)
{
}
#endif
usleep(2000);
DELAYDO = 65000;


/*等待nSTATUS(PE6) = 0  --input*/
/* while((nSTATUS) && (CONF_DONE) && ( --DELAYDO>0 )); */
lseek(nstatus_fd, 0, SEEK_SET);
val = gpio_read_b(nstatus_fd);
while( !((val == 0) && ( DELAYDO>0 )) )
{
lseek(nstatus_fd, 0, SEEK_SET);
val = gpio_read_b(nstatus_fd);
DELAYDO--;

}
// printf("val2:%d;\n",val);



/* 超时,串口打印提示信息*/
if(DELAYDO == 0)
{
printf("DELAYDO timeout!!! \n");
return FALSE;
}


/*nConfig = 1*/
//SET_BIT(GPIOE_PDOR,nCONFIG_MASK);
lseek(nconfig_fd, 0, SEEK_SET);
gpio_write_b(nconfig_fd, 1);
#if 0
for(ulLoop = 0; ulLoop < (490000*2); ulLoop++)
{
}
#endif
usleep(2000);
DELAYDO = 165000;

/*等待nSTATUS = 1*/
lseek(nstatus_fd, 0, SEEK_SET);
val = gpio_read_b(nstatus_fd);

// printf("val5:%d;\n",val);



while( (!val )  ) 
{
lseek(nstatus_fd, 0, SEEK_SET);
val = gpio_read_b(nstatus_fd);
}

/*while((nSTATUS == 1;)  && ( --DELAYDO>0 )); */
/*超时,串口打印提示信息*/
if(DELAYDO == 0)
{
return FALSE;
}

return TRUE;
}




/*-------------------download from code--------------------*/
UINT DownloadFromCode(WORD Length,UCHAR *Address)
{
WORD i;
UCHAR TMP,val;
UCHAR DATA_SEND;
UCHAR j;

for(i=0;i<Length;i++)
{
TMP = Address[i];

for(j=0;j<8;j++)
{
/*DCLK_FPGA = 0;*/
//CLR_BIT(GPIOE_PDOR,DCLK_MASK);
lseek(clk_fd, 0, SEEK_SET);
gpio_write_b(clk_fd, 0);
// fpgadelay(2);


//DATA_SEND = TMP>>j;
DATA_SEND = TMP>>j;

if((DATA_SEND & 0x01))
{
//SET_BIT(GPIOE_PDOR,DATA_MASK);
lseek(data_fd, 0, SEEK_SET);
gpio_write_b(data_fd, 1);
}
else
{
//CLR_BIT(GPIOE_PDOR,DATA_MASK);
lseek(data_fd, 0, SEEK_SET);
gpio_write_b(data_fd, 0);
}
// fpgadelay(2);


/*DCLK_FPGA =1;*/
//SET_BIT(GPIOE_PDOR,DCLK_MASK);
lseek(clk_fd, 0, SEEK_SET);
gpio_write_b(clk_fd, 1);
// fpgadelay(2);
}


lseek(nstatus_fd, 0, SEEK_SET);
val = gpio_read_b(nstatus_fd);


if(!val)
{
return FALSE;
}
}

//CLI_PRINT("\r\n i = %d",i,0,0,0,0,0);
//CLI_PRINT("\r\nDownloadFromCode!\r\n",0,0,0,0,0,0);

return TRUE;
}


void ConfigCpldFromCode(void)
{
UCHAR   p[1024];
ULONG   j;
UINT32 size;
UINT32 len ;
int i = 0;



size = lseek(fpga_dat_fd, 0, SEEK_END);

printf("size=%d \n",size);

lseek(fpga_dat_fd, 0, SEEK_SET);
for(j = 0; j<=size; j+=1024)
{

if(j%(1024*4)==0)
{
printf(".");
}


if((j+1024) > size)
{
len = (size-j);
}
else
{
len = 1024;
}


// lseek(fpga_fd, 1024*i, SEEK_SET);
/*以page大小为读的单位*/
read(fpga_dat_fd, p, len);
i++;
// printf("%d.",i);
if(!DownloadFromCode(len,p))
{
break;
}
}



}




/*配置时间过长：超时  认为硬件自检错误 hardWareErr ＝1;配置起始地址*/
UINT ConfigCpld(void)
{
int ret;
UINT8 Try_configcpld;
char val;
volatile UINT8 num;



Try_configcpld = 0;
printf("ConfigCpld!\r\n");
lseek(nconfig_fd, 0, SEEK_SET);
val = gpio_read_b(nconfig_fd);


// printf("val1:%d;\n",val);

// while( Try_configcpld<2)
{
if(!StartConfig())
{
printf("\n StartConfig error!\n");
return FALSE;
}

lseek(nstatus_fd, 0, SEEK_SET);
val = gpio_read_b(nstatus_fd);

// printf("val6:%d \n",val);
if(!val )
{
printf("\n After Initialization,But the PIN nSTATUS from '1' to '0' !!\n");
}

ConfigCpldFromCode();

printf("\n Config cpld from code OK! \n");


lseek(nstatus_fd, 0, SEEK_SET);
val = gpio_read_b(nstatus_fd);
// printf("val7:%d \n",val);
if(!val)
{
printf("\n After Initialization,But the PIN nSTATUS from '1' to '0' !!\n");
}

Try_configcpld ++;
fpgadelay(10);
}


lseek(conf_done_fd, 0, SEEK_SET);
val = gpio_read_b(conf_done_fd);
// printf("val8:%d \n",val);
if(!val)
{
printf("\n After Configuration,But the PIN CONF_DONE CAN NOT be '1' !!\n");
return FALSE;
}

return TRUE;
}


void InitFpga(void)
{
/* ******************************************************   
nSTATUS=GPIO_15;--input
CONF_DONE=GPIO_07;--input

nCONFIG=GPIO_14;--output//
DCLK = GPIO_06;      --output
DATA = GPIO_10;--output


**********************************************************/

if(!ConfigCpld())
{
printf("Can NOT Initialize FPGA!\n");
return;
}
else
{
printf("Done \r\nConfigure FPGA Successfully !!!\n");
}



}
#if 0
int main(int argc, char *argv[])
{
fpga_fd = open("/ffs/fpga.rbf", O_RDONLY);
if (fpga_fd < 0) 
{ 
MSG("Failed to open fpga.rbf!\n"); 
return -1; 
} 


fpga_gpio_init();
InitFpga();


close(fpga_fd);

}
#endif


int main(int argc, char *argv[])
{
int ret;


fpga_gpio_init();

/* open gpio nconfig file*/
nconfig_fd = open(nCONFIG, O_RDWR);
if (nconfig_fd < 0)
{
printf("can't open nconfig \n");
return;
}

/* open gpio nstatus file*/
nstatus_fd = open(nSTATUS, O_RDWR);
if (nstatus_fd < 0)
{
printf("can't open nstatus \n");
return;
}


/* open fpga.dat file*/
fpga_dat_fd = open(FPGA_DAT, O_RDWR);
if (fpga_dat_fd < 0)
{
printf("can't open fpga.dat \n");
return;
}


/* open gpio clk file*/
clk_fd = open(CLK, O_RDWR);
if (clk_fd < 0)
{
printf("can't open clk \n");
return;
}


/* open gpio data file*/
data_fd = open(DATA, O_RDWR);
if (data_fd < 0)
{
printf("can't open data \n");
return;
}


conf_done_fd = open(CONF_DONE, O_RDWR);
if (data_fd < 0)
{
printf("can't open conf_done \n");
return;
}

InitFpga();


close(nconfig_fd);
close(nstatus_fd);
close(fpga_dat_fd);
close(clk_fd);
close(data_fd);
close(conf_done_fd);


return ret;

}

gpio.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h> 
#include <poll.h>
#include "gpio.h"


int gpio_export(int pin) 
{ 
char buffer[64]; 
int len; 
int fd; 


fd = open("/sys/class/gpio/export", O_WRONLY); 

if (fd < 0) 
{ 
MSG("Failed to open export for writing!\n"); 
return(-1); 
} 


len = snprintf(buffer, sizeof(buffer), "%d", pin); 
if (write(fd, buffer, len) < 0) 
{ 
MSG("Failed to export gpio!\n"); 
return -1; 
} 


close(fd); 
return 0; 
}


int gpio_unexp(int pin) 
{ 
char buffer[64]; 
int len; 
int fd; 


fd = open("/sys/class/gpio/unexport", O_WRONLY); 
if (fd < 0) 
{ 
MSG("Failed to open unexport for writing!\n"); 
return -1; 
} 


len = snprintf(buffer, sizeof(buffer), "%d", pin); 
if (write(fd, buffer, len) < 0) 
{ 
MSG("Failed to unexport gpio!"); 
return -1; 
} 


close(fd); 
return 0; 
}


//dir: 0-->IN, 1-->OUT
int gpio_direction(int pin, int dir) 
{ 
static const char dir_str[] = "in,out"; 
char path[64]; 
int fd; 


snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/direction", pin); 
fd = open(path, O_WRONLY); 

if (fd < 0) 
{ 
MSG("Failed to open gpio direction for writing!\n"); 
return -1; 
} 
if (write(fd, &dir_str[dir == 0 ? 0 : 3], dir == 0 ? 2 : 3) < 0) 
{ 
MSG("Failed to set direction!\n"); 
return -1; 
} 


close(fd); 
return 0; 
}


//value: 0-->LOW, 1-->HIGH
int gpio_write(int pin, int value) 
{ 
static const char values_str[] = "01"; 
char path[64]; 
int fd; 


snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", pin); 
fd = open(path, O_WRONLY); 
if (fd < 0) 
{ 
MSG("Failed to open gpio value for writing!\n"); 
return -1; 
} 


if (write(fd, &values_str[value == 0 ? 0 : 1], 1) < 0) 
{ 
MSG("Failed to write value!\n"); 
return -1; 
} 


close(fd); 
return 0; 
}
int gpio_write_b(int fd, int value) 
{ 
static const char values_str[] = "01"; 
char path[64]; 

if (write(fd, &values_str[value == 0 ? 0 : 1], 1) < 0) 
{ 
MSG("Failed to write value!\n"); 
return -1; 
} 


return 0; 
}


int gpio_read(int pin) 
{ 
char path[64]; 
char value_str[3]; 
int fd; 
snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", pin); 
fd = open(path, O_RDONLY); 

if (fd < 0) 
{ 
MSG("Failed to open gpio value for reading!\n"); 
return -1; 
} 


if (read(fd, value_str, 3) < 0) 
{ 
MSG("Failed to read value!\n"); 
return -1; 
} 


close(fd); 
return (atoi(value_str));
}


int gpio_read_b(int fd) 
{ 
char path[64]; 
char value_str[1]; 

if (read(fd, value_str, 1) < 0) 
{ 
MSG("Failed to read value!\n"); 
return -1; 
} 

return (atoi(value_str));
}
// none -->the pin is input, no interrupt
// rising -->the pin is interrupt input, the rising edge is triggered 
// falling -->the pin is interrupt input, the falling edge is triggered 
// both   -->the pin is interrupt input, the edge is triggered (边沿触发)
// 0-->none, 1-->rising, 2-->falling, 3-->both
int gpio_edge(int pin, int edge)
{
const char dir_str[] = "none\rising\falling\both"; 
char ptr;
char path[64]; 
int fd; 

switch(edge)
{
case 0:
ptr = 0;
break;

case 1:
ptr = 5;
break;

case 2:
ptr = 12;
break;

case 3:
ptr = 20;
break;

default:
ptr = 0;
} 


snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/edge", pin); 
fd = open(path, O_WRONLY); 

if (fd < 0) 
{ 
MSG("Failed to open gpio edge for writing!\n"); 
return -1; 
} 
if (write(fd, &dir_str[ptr], strlen(&dir_str[ptr])) < 0) 
{ 
MSG("Failed to set edge!\n"); 
return -1; 
} 


close(fd); 
return 0; 
}
void fpga_gpio_init()
{
/* fpga gpio init

gpio_06: clk
gpio_14: nconfig     --output
gpio_10: data

gpio_15: nstatus
gpio_07: conf_done   ---input


base add = 480


*/
gpio_export(486);
gpio_export(487);
gpio_export(490);
gpio_export(494);
gpio_export(495);

gpio_direction(486, 1);
gpio_direction(490, 1);
gpio_direction(494, 1);
gpio_direction(495, 0);
gpio_direction(487, 0);
}


#if 0
int main() 
{ 
int gpio_fd, ret;
struct pollfd fds[1];
char buff[10];
unsigned char cnt = 0;


//鎸夐敭寮曡剼鍒濆鍖?
gpio_export(49);
gpio_direction(49, 0);
gpio_edge(49,1);

gpio_fd = open("/sys/class/gpio/gpio49/value",O_RDONLY);
if(gpio_fd < 0)
{
MSG("Failed to open value!\n"); 
return -1; 
}

fds[0].fd = gpio_fd;
fds[0].events = POLLPRI;

ret = read(gpio_fd,buff,10);
if( ret == -1 )
{
MSG("read\n");
}

while(1)
{
ret = poll(fds,1,0);
if( ret == -1 )
MSG("poll\n");

if( fds[0].revents & POLLPRI)
{
ret = lseek(gpio_fd,0,SEEK_SET);
if( ret == -1 )
{
MSG("lseek\n");
}

ret = read(gpio_fd,buff,10);
if( ret == -1 )
{
MSG("read\n");
}

gpio_write(115, cnt++%2);
}

usleep(100000);
}

return 0;
}
#endif