// SPDX-License-Identifier: GPL-2.0-only

  /*
   * lsgpio - example on how to list the GPIO lines on a system
   *
   * Copyright (C) 2015 Linus Walleij
   *

   * Usage:
   *	lsgpio <-n device-name>
   */
  
  #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"

  struct gpio_flag {
  	char *name;

  	unsigned long long mask;

  };
  
  struct gpio_flag flagnames[] = {
  	{

  		.name = "used",
  		.mask = GPIO_V2_LINE_FLAG_USED,
  	},
  	{
  		.name = "input",
  		.mask = GPIO_V2_LINE_FLAG_INPUT,

  	},
  	{
  		.name = "output",

  		.mask = GPIO_V2_LINE_FLAG_OUTPUT,

  	},
  	{
  		.name = "active-low",

  		.mask = GPIO_V2_LINE_FLAG_ACTIVE_LOW,

  	},
  	{
  		.name = "open-drain",

  		.mask = GPIO_V2_LINE_FLAG_OPEN_DRAIN,

  	},
  	{
  		.name = "open-source",

  		.mask = GPIO_V2_LINE_FLAG_OPEN_SOURCE,

  	},

  	{
  		.name = "pull-up",

  		.mask = GPIO_V2_LINE_FLAG_BIAS_PULL_UP,

  	},
  	{
  		.name = "pull-down",

  		.mask = GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN,

  	},
  	{
  		.name = "bias-disabled",

  		.mask = GPIO_V2_LINE_FLAG_BIAS_DISABLED,

  	},

  };

  static void print_attributes(struct gpio_v2_line_info *info)

  {
  	int i;

  	const char *field_format = "%s";

  
  	for (i = 0; i < ARRAY_SIZE(flagnames); i++) {

  		if (info->flags & flagnames[i].mask) {
  			fprintf(stdout, field_format, flagnames[i].name);
  			field_format = ", %s";

  		}
  	}

  
  	if ((info->flags & GPIO_V2_LINE_FLAG_EDGE_RISING) &&
  	    (info->flags & GPIO_V2_LINE_FLAG_EDGE_FALLING))
  		fprintf(stdout, field_format, "both-edges");
  	else if (info->flags & GPIO_V2_LINE_FLAG_EDGE_RISING)
  		fprintf(stdout, field_format, "rising-edge");
  	else if (info->flags & GPIO_V2_LINE_FLAG_EDGE_FALLING)
  		fprintf(stdout, field_format, "falling-edge");
  
  	for (i = 0; i < info->num_attrs; i++) {
  		if (info->attrs[i].id == GPIO_V2_LINE_ATTR_ID_DEBOUNCE)
  			fprintf(stdout, ", debounce_period=%dusec",
  				info->attrs[0].debounce_period_us);
  	}

  }

  int list_device(const char *device_name)
  {
  	struct gpiochip_info cinfo;
  	char *chrdev_name;
  	int fd;
  	int ret;

  	int i;

  
  	ret = asprintf(&chrdev_name, "/dev/%s", device_name);
  	if (ret < 0)
  		return -ENOMEM;
  
  	fd = open(chrdev_name, 0);
  	if (fd == -1) {
  		ret = -errno;
  		fprintf(stderr, "Failed to open %s
  ", chrdev_name);

  		goto exit_free_name;

  	}
  
  	/* Inspect this GPIO chip */
  	ret = ioctl(fd, GPIO_GET_CHIPINFO_IOCTL, &cinfo);
  	if (ret == -1) {
  		ret = -errno;

  		perror("Failed to issue CHIPINFO IOCTL
  ");
  		goto exit_close_error;

  	}

  	fprintf(stdout, "GPIO chip: %s, \"%s\", %u GPIO lines
  ",
  		cinfo.name, cinfo.label, cinfo.lines);

  	/* Loop over the lines and print info */
  	for (i = 0; i < cinfo.lines; i++) {

  		struct gpio_v2_line_info linfo;

  
  		memset(&linfo, 0, sizeof(linfo));

  		linfo.offset = i;

  		ret = ioctl(fd, GPIO_V2_GET_LINEINFO_IOCTL, &linfo);

  		if (ret == -1) {
  			ret = -errno;
  			perror("Failed to issue LINEINFO IOCTL
  ");
  			goto exit_close_error;
  		}

  		fprintf(stdout, "\tline %2d:", linfo.offset);

  		if (linfo.name[0])

  			fprintf(stdout, " \"%s\"", linfo.name);

  		else
  			fprintf(stdout, " unnamed");

  		if (linfo.consumer[0])
  			fprintf(stdout, " \"%s\"", linfo.consumer);

  		else

  			fprintf(stdout, " unused");

  		if (linfo.flags) {
  			fprintf(stdout, " [");

  			print_attributes(&linfo);

  			fprintf(stdout, "]");
  		}
  		fprintf(stdout, "
  ");

  	}

  exit_close_error:
  	if (close(fd) == -1)
  		perror("Failed to close GPIO character device file");

  exit_free_name:

  	free(chrdev_name);

  	return ret;

  }
  
  void print_usage(void)
  {
  	fprintf(stderr, "Usage: lsgpio [options]...
  "
  		"List GPIO chips, lines and states
  "
  		"  -n <name>  List GPIOs on a named device
  "
  		"  -?         This helptext
  "
  	);
  }
  
  int main(int argc, char **argv)
  {

  	const char *device_name = NULL;

  	int ret;
  	int c;
  
  	while ((c = getopt(argc, argv, "n:")) != -1) {
  		switch (c) {
  		case 'n':
  			device_name = optarg;
  			break;
  		case '?':
  			print_usage();
  			return -1;
  		}
  	}
  
  	if (device_name)
  		ret = list_device(device_name);
  	else {
  		const struct dirent *ent;
  		DIR *dp;
  
  		/* List all GPIO devices one at a time */
  		dp = opendir("/dev");
  		if (!dp) {
  			ret = -errno;
  			goto error_out;
  		}
  
  		ret = -ENOENT;
  		while (ent = readdir(dp), ent) {
  			if (check_prefix(ent->d_name, "gpiochip")) {
  				ret = list_device(ent->d_name);
  				if (ret)
  					break;
  			}
  		}
  
  		ret = 0;
  		if (closedir(dp) == -1) {
  			perror("scanning devices: Failed to close directory");
  			ret = -errno;
  		}
  	}
  error_out:
  	return ret;
  }