// SPDX-License-Identifier: GPL-2.0-only
/*
 * gpio-hammer - example swiss army knife to shake GPIO lines on a system
 *
 * Copyright (C) 2016 Linus Walleij
 *
 * Usage:
 *      gpio-hammer -n <device-name> -o <offset1> -o <offset2>
 */

#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdio.h>
#include <dirent.h>
#include <errno.h>
#include <string.h>
#include <poll.h>
#include <fcntl.h>
#include <getopt.h>
#include <sys/ioctl.h>
#include <linux/gpio.h>
#include "gpio-utils.h"

int hammer_device(const char *device_name, unsigned int *lines, int num_lines,
                  unsigned int loops)
{
        struct gpio_v2_line_values values;
        struct gpio_v2_line_config config;
        char swirr[] = "-\\|/";
        int fd;
        int ret;
        int i, j;
        unsigned int iteration = 0;

        memset(&config, 0, sizeof(config));
        config.flags = GPIO_V2_LINE_FLAG_OUTPUT;

        ret = gpiotools_request_line(device_name, lines, num_lines,
                                     &config, "gpio-hammer");
        if (ret < 0)
                goto exit_error;
        else
                fd = ret;

        values.mask = 0;
        values.bits = 0;
        for (i = 0; i < num_lines; i++)
                gpiotools_set_bit(&values.mask, i);

        ret = gpiotools_get_values(fd, &values);
        if (ret < 0)
                goto exit_close_error;

        fprintf(stdout, "Hammer lines [");
        for (i = 0; i < num_lines; i++) {
                fprintf(stdout, "%u", lines[i]);
                if (i != (num_lines - 1))
                        fprintf(stdout, ", ");
        }
        fprintf(stdout, "] on %s, initial states: [", device_name);
        for (i = 0; i < num_lines; i++) {
                fprintf(stdout, "%d", gpiotools_test_bit(values.bits, i));
                if (i != (num_lines - 1))
                        fprintf(stdout, ", ");
        }
        fprintf(stdout, "]\n");

        /* Hammertime! */
        j = 0;
        while (1) {
                /* Invert all lines so we blink */
                for (i = 0; i < num_lines; i++)
                        gpiotools_change_bit(&values.bits, i);

                ret = gpiotools_set_values(fd, &values);
                if (ret < 0)
                        goto exit_close_error;

                /* Re-read values to get status */
                ret = gpiotools_get_values(fd, &values);
                if (ret < 0)
                        goto exit_close_error;

                fprintf(stdout, "[%c] ", swirr[j]);
                j++;
                if (j == sizeof(swirr) - 1)
                        j = 0;

                fprintf(stdout, "[");
                for (i = 0; i < num_lines; i++) {
                        fprintf(stdout, "%u: %d", lines[i],
                                gpiotools_test_bit(values.bits, i));
                        if (i != (num_lines - 1))
                                fprintf(stdout, ", ");
                }
                fprintf(stdout, "]\r");
                fflush(stdout);
                sleep(1);
                iteration++;
                if (loops && iteration == loops)
                        break;
        }
        fprintf(stdout, "\n");
        ret = 0;

exit_close_error:
        gpiotools_release_line(fd);
exit_error:
        return ret;
}

void print_usage(void)
{
        fprintf(stderr, "Usage: gpio-hammer [options]...\n"
                "Hammer GPIO lines, 0->1->0->1...\n"
                "  -n <name>  Hammer GPIOs on a named device (must be stated)\n"
                "  -o <n>     Offset[s] to hammer, at least one, several can be stated\n"
                " [-c <n>]    Do <n> loops (optional, infinite loop if not stated)\n"
                "  -?         This helptext\n"
                "\n"
                "Example:\n"
                "gpio-hammer -n gpiochip0 -o 4\n"
        );
}

int main(int argc, char **argv)
{
        const char *device_name = NULL;
        unsigned int lines[GPIOHANDLES_MAX];
        unsigned int loops = 0;
        int num_lines;
        int c;
        int i;

        i = 0;
        while ((c = getopt(argc, argv, "c:n:o:?")) != -1) {
                switch (c) {
                case 'c':
                        loops = strtoul(optarg, NULL, 10);
                        break;
                case 'n':
                        device_name = optarg;
                        break;
                case 'o':
                        /*
                         * Avoid overflow. Do not immediately error, we want to
                         * be able to accurately report on the amount of times
                         * '-o' was given to give an accurate error message
                         */
                        if (i < GPIOHANDLES_MAX)
                                lines[i] = strtoul(optarg, NULL, 10);

                        i++;
                        break;
                case '?':
                        print_usage();
                        return -1;
                }
        }

        if (i >= GPIOHANDLES_MAX) {
                fprintf(stderr,
                        "Only %d occurrences of '-o' are allowed, %d were found\n",
                        GPIOHANDLES_MAX, i + 1);
                return -1;
        }

        num_lines = i;

        if (!device_name || !num_lines) {
                print_usage();
                return -1;
        }
        return hammer_device(device_name, lines, num_lines, loops);
}