// SPDX-License-Identifier: GPL-2.0
/*
 * GPIO mockup cdev test helper
 *
 * Copyright (C) 2020 Kent Gibson
 */

#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/gpio.h>

#define CONSUMER        "gpio-mockup-cdev"

static int request_line_v2(int cfd, unsigned int offset,
                           uint64_t flags, unsigned int val)
{
        struct gpio_v2_line_request req;
        int ret;

        memset(&req, 0, sizeof(req));
        req.num_lines = 1;
        req.offsets[0] = offset;
        req.config.flags = flags;
        strcpy(req.consumer, CONSUMER);
        if (flags & GPIO_V2_LINE_FLAG_OUTPUT) {
                req.config.num_attrs = 1;
                req.config.attrs[0].mask = 1;
                req.config.attrs[0].attr.id = GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES;
                if (val)
                        req.config.attrs[0].attr.values = 1;
        }
        ret = ioctl(cfd, GPIO_V2_GET_LINE_IOCTL, &req);
        if (ret == -1)
                return -errno;
        return req.fd;
}


static int get_value_v2(int lfd)
{
        struct gpio_v2_line_values vals;
        int ret;

        memset(&vals, 0, sizeof(vals));
        vals.mask = 1;
        ret = ioctl(lfd, GPIO_V2_LINE_GET_VALUES_IOCTL, &vals);
        if (ret == -1)
                return -errno;
        return vals.bits & 0x1;
}

static int request_line_v1(int cfd, unsigned int offset,
                           uint32_t flags, unsigned int val)
{
        struct gpiohandle_request req;
        int ret;

        memset(&req, 0, sizeof(req));
        req.lines = 1;
        req.lineoffsets[0] = offset;
        req.flags = flags;
        strcpy(req.consumer_label, CONSUMER);
        if (flags & GPIOHANDLE_REQUEST_OUTPUT)
                req.default_values[0] = val;

        ret = ioctl(cfd, GPIO_GET_LINEHANDLE_IOCTL, &req);
        if (ret == -1)
                return -errno;
        return req.fd;
}

static int get_value_v1(int lfd)
{
        struct gpiohandle_data vals;
        int ret;

        memset(&vals, 0, sizeof(vals));
        ret = ioctl(lfd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &vals);
        if (ret == -1)
                return -errno;
        return vals.values[0];
}

static void usage(char *prog)
{
        printf("Usage: %s [-l] [-b <bias>] [-s <value>] [-u <uAPI>] <gpiochip> <offset>\n", prog);
        printf("        -b: set line bias to one of pull-down, pull-up, disabled\n");
        printf("               (default is to leave bias unchanged):\n");
        printf("        -l: set line active low (default is active high)\n");
        printf("        -s: set line value (default is to get line value)\n");
        printf("        -u: uAPI version to use (default is 2)\n");
        exit(-1);
}

static int wait_signal(void)
{
        int sig;
        sigset_t wset;

        sigemptyset(&wset);
        sigaddset(&wset, SIGHUP);
        sigaddset(&wset, SIGINT);
        sigaddset(&wset, SIGTERM);
        sigwait(&wset, &sig);

        return sig;
}

int main(int argc, char *argv[])
{
        char *chip;
        int opt, ret, cfd, lfd;
        unsigned int offset, val = 0, abiv;
        uint32_t flags_v1;
        uint64_t flags_v2;

        abiv = 2;
        ret = 0;
        flags_v1 = GPIOHANDLE_REQUEST_INPUT;
        flags_v2 = GPIO_V2_LINE_FLAG_INPUT;

        while ((opt = getopt(argc, argv, "lb:s:u:")) != -1) {
                switch (opt) {
                case 'l':
                        flags_v1 |= GPIOHANDLE_REQUEST_ACTIVE_LOW;
                        flags_v2 |= GPIO_V2_LINE_FLAG_ACTIVE_LOW;
                        break;
                case 'b':
                        if (strcmp("pull-up", optarg) == 0) {
                                flags_v1 |= GPIOHANDLE_REQUEST_BIAS_PULL_UP;
                                flags_v2 |= GPIO_V2_LINE_FLAG_BIAS_PULL_UP;
                        } else if (strcmp("pull-down", optarg) == 0) {
                                flags_v1 |= GPIOHANDLE_REQUEST_BIAS_PULL_DOWN;
                                flags_v2 |= GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN;
                        } else if (strcmp("disabled", optarg) == 0) {
                                flags_v1 |= GPIOHANDLE_REQUEST_BIAS_DISABLE;
                                flags_v2 |= GPIO_V2_LINE_FLAG_BIAS_DISABLED;
                        }
                        break;
                case 's':
                        val = atoi(optarg);
                        flags_v1 &= ~GPIOHANDLE_REQUEST_INPUT;
                        flags_v1 |= GPIOHANDLE_REQUEST_OUTPUT;
                        flags_v2 &= ~GPIO_V2_LINE_FLAG_INPUT;
                        flags_v2 |= GPIO_V2_LINE_FLAG_OUTPUT;
                        break;
                case 'u':
                        abiv = atoi(optarg);
                        break;
                default:
                        usage(argv[0]);
                }
        }

        if (argc < optind + 2)
                usage(argv[0]);

        chip = argv[optind];
        offset = atoi(argv[optind + 1]);

        cfd = open(chip, 0);
        if (cfd == -1) {
                fprintf(stderr, "Failed to open %s: %s\n", chip, strerror(errno));
                return -errno;
        }

        if (abiv == 1)
                lfd = request_line_v1(cfd, offset, flags_v1, val);
        else
                lfd = request_line_v2(cfd, offset, flags_v2, val);

        close(cfd);

        if (lfd < 0) {
                fprintf(stderr, "Failed to request %s:%d: %s\n", chip, offset, strerror(-lfd));
                return lfd;
        }

        if (flags_v2 & GPIO_V2_LINE_FLAG_OUTPUT) {
                wait_signal();
        } else {
                if (abiv == 1)
                        ret = get_value_v1(lfd);
                else
                        ret = get_value_v2(lfd);
        }

        close(lfd);

        return ret;
}