/******************************************************************************
版权所有：
文件名称：	gpio.c
文件版本：	01.01
创建作者:	zhaoyang
创建日期：	2023-12-14
功能说明：	gpio驱动程序。
其它说明：
修改记录：

[new]-->applay
B_DO_ADJ	--> GPIOD_17	-->  gpio113 预置返校
B_DO_0		--> GPIOD_03	-->  gpio99 预置
B_DO_1		--> GPIOD_19	-->  gpio115
B_DO_2		--> GPIOD_02	-->  gpio98
B_DO_3		--> GPIOD_09	-->  gpio105
B_DO_4		--> GPIOD_18	-->  gpio114
B_DO_5		--> GPIOD_16	-->  gpio112
B_DO_6		--> GPIOD_07	-->  gpio103
B_DO_7		--> GPIOD_08	-->  gpio104
B_DO_8		--> GPIOD_06	-->  gpio102

T536 start ↓↓↓↓↓↓
RUN_LED			-->  PB7  	-->  gpio39
ERR_LED			-->  PF4	-->  gpio164
ESAM_PWR		-->  PL7	-->  gpio159
LINE_LOSS_SET	-->  PM5	-->  gpio389
T536 end   ↑↑↑↑↑↑
*/

/*------------------------------- 头文件 --------------------------------------
 */
#include "bspconfig.h"
#include "gpio.h"
#include "head.h"

#include <rtdm/gpio.h>
/*------------------------------- 宏定义 --------------------------------------
 */
#if CFG_BSP_DEBUG

#define _GPIO_DEBUG

#endif

#define GPIO_LOW 0

/*------------------------------ 全局变量 -------------------------------------
 */
typedef enum
{
    SYS_GPIO = 0,
    RTDM_GPIO = 1,
} GPIO_TYPE;

unsigned short kc_kout0_stu;
extern uint32_t g_yx_buf[2]; // 预留64个遥信

/*------------------------------ 函数声明 -------------------------------------
 */
extern unsigned int change_di_ch(unsigned int di);

int gpio_val_fd[DO_NUM];
int gpio_dev_type[DO_NUM] = {
    SYS_GPIO,
}; // 0:系统GPIO, 1:RTDM GPIO

/* 开出gpio */
const int gpio_val[DO_NUM] = {115, 98, 105, 114, 112, 103, 104, 102, 99, 113};

// static int gpio_watchdog_val = 0;
static int gpio_run_led_val = 0;

/*------------------------------ 外部函数 -------------------------------------
 */

int sysfs_gpio_unexport(int gpio)
{
    char path[64];
    int fd;

    snprintf(path, sizeof(path), "/sys/class/gpio/unexport");
    fd = open(path, O_WRONLY);
    if (fd < 0)
    {
        perror("Failed to open unexport");
        return -1;
    }

    char buf[16];
    snprintf(buf, sizeof(buf), "%d", gpio);
    if (write(fd, buf, strlen(buf)) < 0)
    {
        perror("Failed to set GPIO");
        close(fd);
        return -1;
    }
    close(fd);
    return 0;
}

int sysfs_gpio_export(int gpio)
{
    char path[64];
    int fd;

    // 检查是否已导出
    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d", gpio);
    if (access(path, F_OK) == 0)
    {
        sysfs_gpio_unexport(gpio); //	bugfix: 避免重复导出
        msleep(50);                // 短暂等待让内核处理
    }

    snprintf(path, sizeof(path), "/sys/class/gpio/export");
    fd = open(path, O_WRONLY);
    if (fd < 0)
    {
        perror("Failed to open export");
        return -1;
    }

    char buf[16];
    snprintf(buf, sizeof(buf), "%d", gpio);
    if (write(fd, buf, strlen(buf)) < 0)
    {
        perror("Failed to export GPIO");
        close(fd);
        return -2;
    }

    close(fd);
    return 0;
}

int sysfs_gpio_set_direction(int gpio, int is_output)
{
    char path[64];
    int fd;

    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/direction", gpio);
    fd = open(path, O_WRONLY);
    if (fd < 0)
    {
        perror("Failed to open direction");
        return -1;
    }

    if (write(fd, is_output ? "out" : "in", is_output ? 3 : 2) < 0)
    {
        perror("Failed to set direction");
        close(fd);
        return -1;
    }

    close(fd);
    return 0;
}

int sysfs_gpio_set_edge_detect(int gpio, int edge)
{
    char path[64];
    int fd;

    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/edge", gpio);
    fd = open(path, O_WRONLY);
    if (fd < 0)
    {
        perror("Failed to open edge");
        close(fd);
        return -1;
    }

    if (write(fd, edge, strlen(edge)) < 0)
    {
        perror("Failed to set edge");
        close(fd);
        return -1;
    }

    close(fd);
    return 0;
}

int sysfs_gpio_set_value(int gpio, int value)
{
    char path[64];
    int fd = -1;

    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", gpio);
    fd = open(path, O_WRONLY);
    if (fd < 0)
    {
        perror("Failed to open value");
        return -1;
    }

    if (write(fd, value ? "1" : "0", 1) < 0)
    {
        perror("Failed to set value");
        close(fd);
        return -1;
    }

    return fd;
}

int sysfs_gpio_init(int gpio, int direction)
{
    int ret;
    ret = sysfs_gpio_export(gpio);
    if (ret < 0)
    {
        dp_err_n_c("sysfs_gpio_export error ret = %d!", ret);
        return -1;
    }
    ret = sysfs_gpio_set_direction(gpio, direction);
    if (ret < 0)
    {
        dp_err_n_c("sysfs_gpio_set_direction error");
    }

    return sysfs_gpio_set_value(gpio, GPIO_LOW); // 初始化IO为低电平
}

int is_rtdm_device(int fd)
{
    if (gpio_dev_type[fd] > SYS_GPIO)
        return 1;
    else if (gpio_dev_type[fd] == SYS_GPIO)
        return 0;
    else
        return -1;
}

int rt_write(int fd, char *buf, int len)
{
    int value;

    if (len <= 0 || buf == NULL)
    {
        return -1;
    }
    if (is_rtdm_device(fd) == 1)
    {
        // Xenomai RTDM设备：需要转换为二进制值
        value = atoi(buf);
        if (value != 0 && value != 1)
        {
            dp_err_n_c("value :%d ERR, Please enter '0' or '1'", value);
            return -1;
        }
        return write(fd, &value, sizeof(value));
    }
    else
    {
        // 常规系统设备：直接传递字符串
        return write(fd, buf, len);
    }
}

int rt_read(int fd, char *buf, int len)
{
    int ret = 0;

    if (is_rtdm_device(fd) == 1)
    {
        dp_info_n_c("fd = %d", fd);
        // Xenomai RTDM设备：读取二进制值
        int value = 0;

        // 从RTDM设备读取二进制状态（通常是4字节的int）
        ret = read(fd, &value, sizeof(value));
        dp_info_n_c("ret = %d", ret);
        if (ret != sizeof(value))
        {
            dp_err_n_c("Failed to read from RTDM device, ret=%d", ret);
            return -1;
        }

        // 将二进制值转换为字符'0'或'1'
        if (value == 0)
        {
            buf[0] = '0';
        }
        else if (value == 1)
        {
            buf[0] = '1';
        }
        else
        {
            dp_err_n_c("Unexpected value from RTDM device: %d", value);
            return -1;
        }

        buf[1] = '\0'; // 字符串结束符
        return 1;      // 读取到的字符数
    }
    else
    {
        // 常规系统设备：直接读取字符串
        ret = read(fd, buf, len);
        dp_err_n_c("ret=%d", ret);
        if (ret < 0)
        {
            dp_err_n_c("Failed to read from regular device");
            return -1;
        }

        buf[ret] = '\0'; // 确保字符串正确结束

        // 移除可能的换行符
        if (ret > 0 && buf[ret - 1] == '\n')
        {
            buf[ret - 1] = '\0';
            ret--;
        }

        return ret; // 返回读取的字符数
    }
}

int rtdm_gpio_init(int gpio, int direction)
{
    char path[64];
    int fd = -1, ret;
    int value = 1;
    snprintf(path, sizeof(path), "/dev/rtdm/3604000.pinctrl/gpio%d", gpio);
    fd = open(path, O_RDWR);
    if (fd < 0)
    {
        perror("open");
        return -1;
    }

    if (113 == gpio) /* 预置返校是开入 */
    {
        ret = ioctl(fd, GPIO_RTIOC_DIR_IN, &value);
    }
    else
    {
        ret = ioctl(fd, GPIO_RTIOC_DIR_OUT, &value);
    }
    if (ret < 0)
    {
        perror("ioctl DIR_OUT");
        close(fd);
        return -1;
    }

    return fd;
}

int gpio_init(void)
{
#define GPIO_OUTPUT 1
    int i;

    for (i = 0; i < DO_NUM; i++)
    {
        gpio_val_fd[i] = rtdm_gpio_init(gpio_val[i], GPIO_OUTPUT);
        if (gpio_val_fd[i] < 0)
        {
            gpio_val_fd[i] = sysfs_gpio_init(gpio_val[i], GPIO_OUTPUT);
            dp_info_n_c("gpio_val_fd[%02d] = %d", i, gpio_val_fd[i]);
            if (gpio_val_fd[i] < 0)
            {
                dp_err_n_c("gpio_val_fd[%d] error", i);
                gpio_val_fd[i] = -1;
                gpio_dev_type[i] = -1;
                return -1;
            }
        }
        else
        {
            gpio_dev_type[i] = gpio_val_fd[i]; // 保存RTDM设备类型句柄,这里有风险，fd句柄可能为0
        }
    }

    msleep(10); // 延时10ms

    kc_kout0_stu = 0;

    for (i = DO_OUT1; i < DO_NUM; i++)
    {
        rt_write(gpio_val_fd[i], "1", 2);
    }

    return 0;
}

int gpio_exit(void)
{
    int i;

    for (i = 0; i < DO_NUM; i++)
    {
        if (gpio_val_fd[i] >= 0)
        {
            close(gpio_val_fd[i]);
            gpio_val_fd[i] = -1;
        }
        sysfs_gpio_unexport(gpio_val[i]);
    }

    return 0;
}

/******************************************************************************
函数名称：	gpio_get_di
函数版本：	01.01
创建作者：
创建日期：	2014-11-28
函数说明：	得到开入的状态
参数说明：	无
返回值：  	返回开入的状态，每个bit代表一个开入量。
修改记录：
*/
unsigned int gpio_get_di(void)
{
    unsigned int dw = 0;

    dw = g_yx_buf[0]; // 这里保存的是共享内存的yx值，156us更新一次

    return change_di_ch(~dw); // 取反---因为没有短接时，值为1. 所以要取反为0才行
}

/******************************************************************************
函数名称：	gpio_di_fj
函数版本：	01.01
创建作者：
创建日期：	2014-11-28
函数说明：	读取开出返校遥信值,控制板遥信为YX17~YX18
            YX17:选择, YX18:执行

参数说明：	 无
返回值：  返回遥信值
修改记录：
*/
#ifdef DO_KOUT_CHECK
unsigned short gpio_di_fj(unsigned char index) //(void)
#else
unsigned short gpio_di_fj(void)
#endif
{
    unsigned int di = 0;
    unsigned short ret = 0;

    di = gpio_get_di();
#ifdef DO_KOUT_CHECK
    ret = (unsigned short)((di >> index) & 0x0001);
#else
    ret = (unsigned short)((di >> 23) & 0x0001);
#endif
    return ret;
}

/**
 * @brief          读取预置返校的状态
 * @author         lch (lch_work@foxmail.com)
 * @version        1.0
 * @date           20251229
 * @return         * int
 * @retval         none
 *
 * @warning        none
 * @note           none
 */
int gpioio_get_perset_status(void)
{
    char buf[2] = {0};
    int ret = 0;

    if (gpio_val_fd[DO_IN_PRESET] < 0)
    {
        dp_err_n_c("gpio_val_fd[DO_IN_PRESET] = %d, not initialized", gpio_val_fd[DO_IN_PRESET]);
        return -1;
    }

    ret = read(gpio_val_fd[DO_IN_PRESET], buf, sizeof(buf));
    if (ret > 0)
    {
        return buf[0] - '0'; // 字符转换为数字
    }

    return -1;
}

/******************************************************************************
函数名称：	gpio_kout_do
函数版本：	01.01
创建作者：
创建日期：	2014-11-28
函数说明：	开出

参数说明：	on: 1开出, 0回收
            kout: 那一路
返回值：  无
修改记录：
*/
int gpio_kout_do(int on, unsigned int kout)
{
    int l_ret = -1;
    if (kout > DO_OUT_PRESET)
        return;

    if (on)
    {
        l_ret = rt_write(gpio_val_fd[kout + DO_OUT0], "0", 2);
        // dp_info_n_c("kout = %d, on = %d, l_ret = %d", kout, on, l_ret);
    }
    else
    {
        l_ret = rt_write(gpio_val_fd[kout + DO_OUT0], "1", 2);
        // dp_info_n_c("kout = %d, on = %d, l_ret = %d", kout, on, l_ret);
    }
    return l_ret;
}

/******************************************************************************
函数名称：	gpio_get_wirelessin
函数版本：	01.01
创建作者:	   sunxi
创建日期：	2008-09-16
函数说明：	得到无线遥控的状态。
参数说明：	无
返回值：  	返回开入的状态，每个bit代表一个开入量。
修改记录：
*/
unsigned int gpio_get_wirelessin(void)
{
    register unsigned int dw = 0;

    return dw;
}

unsigned int gpio_get_version(void)
{
    register unsigned int dw = 0;

    return dw;
}

unsigned int gpio_get_addr(void)
{
    register unsigned int dw = 0;

    return dw;
}

void _led_run_err(void)
{
    // 上电就亮错误灯，有错误就继续亮没有就熄灭
    static uint8 err_led = 2;

    if (rt_err_count())
    {
        // 错误指示灯常亮且运行熄灭
        if (!(err_led & 0x01))
        {
            err_led |= 1;
            // write(gpio_val_fd_other[ERR_LED], "0", 2);
            // write(gpio_val_fd_other[RUN_LED], "1", 2);
        }
        return;
    }

    if (err_led)
    {
        err_led = 0;
        // write(gpio_val_fd_other[ERR_LED], "1", 2);
    }

    // 运行指示灯,每隔1s改变状态一次
    if (!gpio_run_led_val)
    {
        gpio_run_led_val = 1;
        // write(gpio_val_fd_other[RUN_LED], "0", 2);
    }
    else
    {
        gpio_run_led_val = 0;
        // write(gpio_val_fd_other[RUN_LED], "1", 2);
    }
}

void esam_power_ctrl(int on)
{
    // if (on)
    //     write(gpio_val_fd_other[ESAM_PWR], "1", 2);
    // else
    //     write(gpio_val_fd_other[ESAM_PWR], "0", 2);
}

/*------------------------------ 内部函数 -------------------------------------
 */

/*------------------------------ 测试函数 -------------------------------------
 */
#ifdef _GPIO_DEBUG
#include "ustimer.h"
#include "rt.h"

int test_kc_function(void)
{
    rt_write(gpio_val_fd[DO_OUT_PRESET], "0", 2); // 预置动作
    char gpio_state[2];
    int ret;
    sleep(1);

#if (1)
    // 读取GPIO状态
    ret = rt_read(gpio_val_fd[DO_IN_PRESET], gpio_state, sizeof(gpio_state));
    printf("ret: %d\n", ret);
    if (ret > 0)
    {
        gpio_state[ret] = '\0';             // 添加字符串结束符
        printf("PRESET: %s\n", gpio_state); // 应该是"0"或"1"
    }
#endif
    rt_write(gpio_val_fd[DO_OUT0], "0", 2);
    sleep(1);
    rt_write(gpio_val_fd[DO_OUT0], "1", 2);

    rt_write(gpio_val_fd[DO_OUT1], "0", 2);
    sleep(1);
    rt_write(gpio_val_fd[DO_OUT1], "1", 2);

#if (0)

    rt_write(gpio_val_fd[DO_OUT2], "0", 2);
    sleep(5);
    rt_write(gpio_val_fd[DO_OUT2], "1", 2);

    rt_write(gpio_val_fd[DO_OUT3], "0", 2);
    sleep(5);
    rt_write(gpio_val_fd[DO_OUT3], "1", 2);
#endif

    rt_write(gpio_val_fd[DO_OUT_PRESET], "1", 2); // 预置动作
    sleep(1);

#if (1)
    // 读取GPIO状态
    ret = rt_read(gpio_val_fd[DO_IN_PRESET], gpio_state, sizeof(gpio_state));
    printf("ret: %d\n", ret);
    if (ret > 0)
    {
        gpio_state[ret] = '\0';             // 添加字符串结束符
        printf("PRESET: %s\n", gpio_state); // 应该是"0"或"1"
    }
#endif

#if (0)
    rt_write(gpio_val_fd[DO_OUT4], "0", 2);
    sleep(5);
    rt_write(gpio_val_fd[DO_OUT4], "1", 2);

    rt_write(gpio_val_fd[DO_OUT5], "0", 2);
    sleep(5);
    rt_write(gpio_val_fd[DO_OUT5], "1", 2);

    rt_write(gpio_val_fd[DO_OUT6], "0", 2);
    sleep(5);
    rt_write(gpio_val_fd[DO_OUT6], "1", 2);

    rt_write(gpio_val_fd[DO_OUT7], "0", 2);
    sleep(5);
    rt_write(gpio_val_fd[DO_OUT7], "1", 2);
#endif
}

#endif