#if 1
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>  //define O_WRONLY and O_RDONLY
#include "../inc/type.h"
#include "../inc/igpio.h"
#include "../inc/isys_com.h"


extern int executeCMD(const char *cmd, char *result, u16 result_size);
pthread_mutex_t  mutex_gpio;


#define DIR_OUT_VAL      "out"
#define DIR_IN_VAL       "in"
#define GP_VAL_H         "1"
#define GP_VAL_L         "0"


int set_gpio_export(uint16_t gp_num)
{
#if SHELL_CTRL_GPIO
    char cmd[300];
    memset(cmd, 0, sizeof(cmd));
    sprintf(cmd, "echo %d > /sys/class/gpio/export",gp_num);
    system(cmd);
#else
	int  fd;
    char s_gp_num[20];

    pthread_mutex_lock(&mutex_gpio);
    fd = open("/sys/class/gpio/export", O_WRONLY);
    if(fd == -1) {
		pthread_mutex_unlock(&mutex_gpio);
        log_printf(LOG_ERR, I_NOUSED, "gpio %d pin open-export error.\n", gp_num);
        return -1;
    }
    memset(s_gp_num,0,sizeof(s_gp_num));
    sprintf(s_gp_num,"%d",gp_num);
    write(fd, s_gp_num ,strlen(s_gp_num));
	close(fd);
	pthread_mutex_unlock(&mutex_gpio);
#endif
    return 0;
}



int set_gpio_unexport(uint16_t gp_num)
{
#if SHELL_CTRL_GPIO
    char cmd[300];
    memset(cmd, 0, sizeof(cmd));
    sprintf(cmd, "echo %d > /sys/class/gpio/unexport",gp_num);
    system(cmd);
#else
	int  fd;
    char s_gp_num[20];

	pthread_mutex_lock(&mutex_gpio);
    fd = open("/sys/class/gpio/unexport", O_WRONLY);
    if(fd == -1){
    	pthread_mutex_unlock(&mutex_gpio);
        log_printf(LOG_ERR,I_NOUSED,"ERR: gpio %d pin open-unexport error.\n",gp_num);
        return -1;
    }
    log_printf(LOG_DEBUG,I_NOUSED,".setxpt sys/gpio/class/gpio/unexport");

    memset(s_gp_num,0,sizeof(s_gp_num));
    sprintf(s_gp_num,"%d",gp_num);

    write(fd, s_gp_num ,strlen(s_gp_num));
    close(fd);
	pthread_mutex_unlock(&mutex_gpio);
#endif
    return 0;
}


int set_gpio_io_direct(uint16_t gp_num,E_IO io_dir)
{
	int  fd;
    char cmd[300];
    memset(cmd, 0, sizeof(cmd));

#if SHELL_CTRL_GPIO
    sprintf(cmd, "echo %s > /sys/class/gpio/gpio%d/direction",(io_dir==E_IO_OUT?"out":"in"),gp_num);
    system(cmd);
#else
	
    if(io_dir==E_IO_OUT) {
        sprintf(cmd, "/sys/class/gpio/gpio%d/direction",gp_num);
    }
    else{//E_IO_IN
        sprintf(cmd, "/sys/class/gpio/gpio%d/direction",gp_num);
    }

	pthread_mutex_lock(&mutex_gpio);
    fd = open(cmd, O_WRONLY);
    if(fd == -1) {
		pthread_mutex_unlock(&mutex_gpio);
        log_printf(LOG_ERR, I_NOUSED, "set io_dir, gpio %d pin open-direction error.\n",gp_num);
        return -1;
    }
    if(io_dir==E_IO_OUT) {
        write(fd, DIR_OUT_VAL, sizeof(DIR_OUT_VAL));
    }
    else{
        write(fd, DIR_IN_VAL, sizeof(DIR_IN_VAL));
    }
	close(fd);
	pthread_mutex_unlock(&mutex_gpio);
#endif
    return 0;
}


int set_gpio_value(uint16_t gp_num, E_IO_VAL val)
{
	int  fd;
    char cmd[200];
    memset(cmd, 0, sizeof(cmd));

#if SHELL_CTRL_GPIO
    sprintf(cmd, "echo %d > /sys/class/gpio/gpio%d/value",val,gp_num);
    system(cmd);
#else
	char   logbuf[50]={0};
    sprintf(cmd, "/sys/class/gpio/gpio%d/value",gp_num);

	pthread_mutex_lock(&mutex_gpio);
    fd = open(cmd, O_WRONLY);
    if(fd == -1){
    	pthread_mutex_unlock(&mutex_gpio);
    	sprintf(logbuf,"error. set_io_val %d open\n",gp_num);
		usr_sec_printf("%s",logbuf);
        return -1;
    }

    if(val==E_IO_H){
        write(fd, GP_VAL_H, sizeof(GP_VAL_H));
    }
    else{
        write(fd, GP_VAL_L, sizeof(GP_VAL_L));
    }
	close(fd);
	pthread_mutex_unlock(&mutex_gpio);
#endif
    return 0;
}

int get_gpio_value(uint16_t gp_num, uint8 *pval)
{
#if SHELL_CTRL_GPIO
    char   cmd[300];
    char   vbuf[20];
    int ret = 0;

    sprintf(cmd, "cat /sys/class/gpio/gpio%d/value",gp_num);
    ret = executeCMD(cmd, vbuf, sizeof(cmd));
    if(ret>=0){
        *pval = atoi(vbuf);
    }else{
        log_printf(LOG_ERR,I_NOUSED,"%s  get value err\n", cmd);
    }
#else
	int    fd;
    char   cmd[300];
    char   vbuf[20];
    uint8  u8val;
	char   logbuf[50]={0};

    memset(cmd, 0, sizeof(cmd));

    sprintf(cmd, "/sys/class/gpio/gpio%d/value",gp_num);
	pthread_mutex_lock(&mutex_gpio);
    fd = open(cmd, O_RDONLY);
    if(fd == -1){
    	pthread_mutex_unlock(&mutex_gpio);
    	sprintf(logbuf,"error. get_io_val %d open\n",gp_num);
		usr_sec_printf("%s",logbuf);
        return -1;
    }

    memset(vbuf,0,sizeof(vbuf));
	read(fd, vbuf, sizeof(vbuf));

    if(vbuf!=NULL){
        u8val = atoi(vbuf);
        *pval = u8val;
    }
    else{
        log_printf(LOG_DEBUG,I_NOUSED,"gpio read err\n");
    }
	close(fd);
	pthread_mutex_unlock(&mutex_gpio);
#endif
    return 0;
}

void key_gpio_init(void)
{
    /*printf("\n\ninit key gpio unexport.\n");
    set_gpio_unexport(KEY1_GP_NUM);
    set_gpio_unexport(KEY2_GP_NUM);
    set_gpio_unexport(KEY3_GP_NUM);
    set_gpio_unexport(KEY4_GP_NUM);
    set_gpio_unexport(KEY5_GP_NUM);
    set_gpio_unexport(KEY6_GP_NUM);*/

    log_printf(LOG_INFO, I_SYS_STATUS, "init key gpio export\n");
    set_gpio_export(KEY1_GP_NUM);
    set_gpio_export(KEY2_GP_NUM);
    set_gpio_export(KEY3_GP_NUM);
    set_gpio_export(KEY4_GP_NUM);
    set_gpio_export(KEY5_GP_NUM);
    set_gpio_export(KEY6_GP_NUM);
    log_printf(LOG_INFO, I_SYS_STATUS, "over. init key gpio export\n");

    log_printf(LOG_INFO, I_SYS_STATUS, "init key gpio input\n");
    set_gpio_io_direct(KEY1_GP_NUM, E_IO_IN);//E_IO_IN
    set_gpio_io_direct(KEY2_GP_NUM, E_IO_IN);
    set_gpio_io_direct(KEY3_GP_NUM, E_IO_IN);
    set_gpio_io_direct(KEY4_GP_NUM, E_IO_IN);
    set_gpio_io_direct(KEY5_GP_NUM, E_IO_IN);
    set_gpio_io_direct(KEY6_GP_NUM, E_IO_IN);
    log_printf(LOG_INFO, I_SYS_STATUS, "over. init key gpio input\n");
}

#define KEY_GPIO_MAX_NUM    6
uint8 key_gp_list[KEY_GPIO_MAX_NUM]=
{
    KEY1_GP_NUM  ,
    KEY2_GP_NUM  ,
    KEY3_GP_NUM  ,
    KEY4_GP_NUM  ,
    KEY5_GP_NUM  ,
    KEY6_GP_NUM  ,
};

#define LCD_GPIO_MAX_NUM    12
uint8 lcd_gp_list[LCD_GPIO_MAX_NUM]=
{
    LCD_CTL_GP_NUM  ,
    LCD_RS_GP_NUM   ,
    LCD_E_GP_NUM    ,
    LCD_RW_GP_NUM   ,
    LCD_D1_GP_NUM   ,
    LCD_D0_GP_NUM   ,
    LCD_D3_GP_NUM   ,
    LCD_D2_GP_NUM   ,
    LCD_D5_GP_NUM   ,
    LCD_D4_GP_NUM   ,
    LCD_D7_GP_NUM   ,
    LCD_D6_GP_NUM   ,
};

void gpio_mutex_init(void)
{
	pthread_mutex_init(&mutex_gpio, NULL);
}

void fpga_reset_gpio_init(void)
{
	set_gpio_export(FPGA_RST_GP_NUM);
	set_gpio_io_direct(FPGA_RST_GP_NUM,E_IO_OUT);
}

void lcd_gpio_init(void)
{
    log_printf(LOG_INFO, I_SYS_STATUS, "init lcd gpio export\n");
    set_gpio_export(LCD_CTL_GP_NUM);
    set_gpio_export(LCD_RS_GP_NUM);
    set_gpio_export(LCD_E_GP_NUM);
    set_gpio_export(LCD_RW_GP_NUM);
    set_gpio_export(LCD_D1_GP_NUM);
    set_gpio_export(LCD_D0_GP_NUM);
    set_gpio_export(LCD_D3_GP_NUM);
    set_gpio_export(LCD_D2_GP_NUM);
    set_gpio_export(LCD_D5_GP_NUM);
    set_gpio_export(LCD_D4_GP_NUM);
    set_gpio_export(LCD_D7_GP_NUM);
    set_gpio_export(LCD_D6_GP_NUM);
    log_printf(LOG_INFO, I_SYS_STATUS, "over. init lcd gpio export\n");


    log_printf(LOG_INFO, I_SYS_STATUS, "init lcd gpio output\n");
    set_gpio_io_direct(LCD_CTL_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_RS_GP_NUM, E_IO_OUT);
    set_gpio_io_direct(LCD_E_GP_NUM,  E_IO_OUT);
    set_gpio_io_direct(LCD_RW_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D1_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D0_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D3_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D2_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D5_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D4_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D7_GP_NUM,E_IO_OUT);
    set_gpio_io_direct(LCD_D6_GP_NUM,E_IO_OUT);
    log_printf(LOG_INFO, I_SYS_STATUS, "over. init lcd gpio output\n");


    set_gpio_export(LCD_EN_GP_NUM);
    set_gpio_io_direct(LCD_EN_GP_NUM, E_IO_OUT);
    set_gpio_value(LCD_EN_GP_NUM, E_IO_H);
}



void i2c_gpio_init(void)
{
    log_printf(LOG_DEBUG,I_NOUSED,"\n\n>>>:init i2c gpio export.\n");
    set_gpio_export(I2C2_SDA_GP_NUM);
    set_gpio_export(I2C2_SCL_GP_NUM);

    set_gpio_export(I2C1_SDA_GP_NUM);
    set_gpio_export(I2C1_SCL_GP_NUM);
    log_printf(LOG_DEBUG,I_NOUSED,"\n\n===:over. init i2c gpio export.\n");

    log_printf(LOG_DEBUG,I_NOUSED,"\n\n>>>:init i2c gpio input.\n");
    set_gpio_io_direct(I2C2_SDA_GP_NUM, E_IO_OUT);//E_IO_IN
    set_gpio_io_direct(I2C2_SCL_GP_NUM, E_IO_OUT);

    set_gpio_io_direct(I2C1_SDA_GP_NUM, E_IO_OUT);
    set_gpio_io_direct(I2C1_SCL_GP_NUM, E_IO_OUT);
    log_printf(LOG_DEBUG,I_NOUSED,"\n\n===:over. init i2c gpio output.\n");
}




#if 0//test

void test_gpio_init()
{
    key_gpio_init();
    lcd_gpio_init();
}

void test_key_lcd_gpio(void)
{

    static uint32 sec_cnt;
    uint8  gp=0;

    sec_cnt++;

    for(gp=0;gp<KEY_GPIO_MAX_NUM;gp++){
        set_gpio_value(key_gp_list[gp], (E_IO_VAL)(sec_cnt%2));
    }

    for(gp=0;gp<LCD_GPIO_MAX_NUM;gp++){
        set_gpio_value(lcd_gp_list[gp], (E_IO_VAL)(sec_cnt%2));
    }
}


#include "time.h"
void main()
{
    int sec_cnt=0;
    uint8 rdata=0;

    test_gpio_init();

    while(1)
    {
        sleep(2);
        sec_cnt++;
        test_key_lcd_gpio();

        printf(".test round %d\n",sec_cnt);
    }
}
#endif

#endif