--- /dev/null
+# SPDX-FileCopyrightText: 2023 Nikita Shubin <me@maquefel.me>
+# SPDX-License-Identifier: CC0-1.0
+CC=$(CROSS_COMPILE)gcc
+
+CFLAGS+=-Wall -std=gnu11 -D_GNU_SOURCE -fPIC
+
+# VERSION
+MAJOR=0
+MINOR=0
+PATCH=0
+VERSION = -DVERSION_MAJOR=$(MAJOR) -DVERSION_MINOR=$(MINOR) -DVERSION_PATCH=$(PATCH)
+
+INCLUDE += -Isrc/
+
+.PHONY: all
+all: \
+ lsgpio \
+ gpio-event-mon \
+ gpio-hammer
+
+.PHONY: debug
+debug: CFLAGS+= -O0 -DDEBUG -ggdb -g3 -Wno-unused-variable
+debug: all
+
+.PHONY: gcov
+gcov: CFLAGS+= -fprofile-arcs -ftest-coverage -DGCOV=1 -DGCOV_PREFIX="${CURDIR}"
+gcov: debug
+
+.PHONY: asan
+asan: CFLAGS+= -fsanitize=address -fsanitize=leak
+asan: gcov
+
+.PHONY: error-check
+error-check: CFLAGS+=-Werror -O
+error-check: all
+
+.PHONY: tests
+tests: asan
+ make -C tests asan
+
+lsgpio: lsgpio.o
+ $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+lsgpio.o: src/lsgpio.c
+ $(CC) $(CFLAGS) -c src/lsgpio.c $(INCLUDE)
+
+gpio-event-mon: gpio-event-mon.o gpio-utils.o
+ $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+gpio-event-mon.o: src/gpio-event-mon.c
+ $(CC) $(CFLAGS) -c src/gpio-event-mon.c $(INCLUDE)
+
+gpio-hammer: gpio-hammer.o gpio-utils.o
+ $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+gpio-hammer.o: src/gpio-hammer.c
+ $(CC) $(CFLAGS) -c src/gpio-hammer.c $(INCLUDE)
+
+gpio-utils.o: src/gpio-utils.c
+ $(CC) $(CFLAGS) -c src/gpio-utils.c $(INCLUDE)
+
+DESTDIR=
+prefix = /usr/local
+exec_prefix = $(DESTDIR)$(prefix)
+bindir = $(exec_prefix)/bin
+
+.PHONY: install uninstall
+install: all
+ install -v -m 0755 lsgpio $(bindir)/lsgpio
+
+uninstall:
+ -rm $(sbindir)/lsgpio
+
+clean::
+ -rm *.o lsgpio
+
+html:
+ mkdir -p $@
+
+.PHONY: report
+
+report: html asan tests
+ lcov -t "lsgpio" -o lsgpio.info -c -d .
+ lcov --remove lsgpio.info \
+ '*cmdline.*' \
+ '*daemonize*' \
+ '*tests/*' \
+ -o lsgpio.info
+ genhtml -o html lsgpio.info
+
+clean::
+ -rm *.gcda *.gcno
+ -rm -rf html
+ -rm -rf lsgpio.info
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * gpio-event-mon - monitor GPIO line events from userspace
+ *
+ * Copyright (C) 2016 Linus Walleij
+ *
+ * Usage:
+ * gpio-event-mon -n <device-name> -o <offset>
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <errno.h>
+#include <string.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <linux/gpio.h>
+#include "gpio-utils.h"
+
+int monitor_device(const char *device_name,
+ unsigned int *lines,
+ unsigned int num_lines,
+ struct gpio_v2_line_config *config,
+ unsigned int loops)
+{
+ struct gpio_v2_line_values values;
+ struct sockaddr_un addr;
+ int cfd, lfd;
+ int ret;
+ int i = 0;
+
+ cfd = socket(AF_UNIX, SOCK_STREAM, 0);
+ memset(&addr, 0, sizeof(addr));
+
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, device_name, sizeof(addr.sun_path) - 1);
+
+ ret = connect(cfd, (const struct sockaddr *) &addr, sizeof(addr));
+ if (ret == -1) {
+ ret = -errno;
+ fprintf(stderr, "Failed to open %s with %s[%d]\n", device_name, strerror(ret), ret);
+ return ret;
+ }
+
+ ret = gpiotools_request_line(cfd, lines, num_lines, config,
+ "gpio-event-mon");
+ if (ret < 0)
+ goto exit_device_close;
+ else
+ lfd = ret;
+
+ /* Read initial states */
+ values.mask = 0;
+ values.bits = 0;
+ for (i = 0; i < num_lines; i++)
+ gpiotools_set_bit(&values.mask, i);
+ ret = gpiotools_get_values(lfd, &values);
+ if (ret < 0) {
+ fprintf(stderr,
+ "Failed to issue GPIO LINE GET VALUES IOCTL (%d)\n",
+ ret);
+ goto exit_line_close;
+ }
+
+ if (num_lines == 1) {
+ fprintf(stdout, "Monitoring line %d on %s\n", lines[0], device_name);
+ fprintf(stdout, "Initial line value: %d\n",
+ gpiotools_test_bit(values.bits, 0));
+ } else {
+ fprintf(stdout, "Monitoring lines %d", lines[0]);
+ for (i = 1; i < num_lines - 1; i++)
+ fprintf(stdout, ", %d", lines[i]);
+ fprintf(stdout, " and %d on %s\n", lines[i], device_name);
+ fprintf(stdout, "Initial line values: %d",
+ gpiotools_test_bit(values.bits, 0));
+ for (i = 1; i < num_lines - 1; i++)
+ fprintf(stdout, ", %d",
+ gpiotools_test_bit(values.bits, i));
+ fprintf(stdout, " and %d\n",
+ gpiotools_test_bit(values.bits, i));
+ }
+
+ i = 0;
+ while (1) {
+ struct gpio_v2_line_event event;
+
+ ret = recv(lfd, &event, sizeof(event), MSG_WAITALL);
+ if (ret == -1) {
+ if (errno == -EAGAIN) {
+ fprintf(stderr, "nothing available\n");
+ continue;
+ } else {
+ ret = -errno;
+ fprintf(stderr, "Failed to read event (%d)\n",
+ ret);
+ break;
+ }
+ }
+
+ if (ret != sizeof(event)) {
+ fprintf(stderr, "Reading event failed expected %d got %d\n", sizeof(event), ret);
+ ret = -EIO;
+ break;
+ }
+
+ fprintf(stdout, "GPIO EVENT at %" PRIu64 " on line %d (%d|%d) ",
+ (uint64_t)event.timestamp_ns, event.offset, event.line_seqno,
+ event.seqno);
+ switch (event.id) {
+ case GPIO_V2_LINE_EVENT_RISING_EDGE:
+ fprintf(stdout, "rising edge");
+ break;
+ case GPIO_V2_LINE_EVENT_FALLING_EDGE:
+ fprintf(stdout, "falling edge");
+ break;
+ default:
+ fprintf(stdout, "unknown event");
+ }
+ fprintf(stdout, "\n");
+
+ i++;
+ if (i == loops)
+ break;
+ }
+
+exit_line_close:
+ if (close(lfd) == -1)
+ perror("Failed to close line file");
+exit_device_close:
+ if (close(cfd) == -1)
+ perror("Failed to close GPIO character device file");
+
+ return ret;
+}
+
+void print_usage(void)
+{
+ fprintf(stderr, "Usage: gpio-event-mon [options]...\n"
+ "Listen to events on GPIO lines, 0->1 1->0\n"
+ " -n <name> Listen on GPIOs on a named device (must be stated)\n"
+ " -o <n> Offset of line to monitor (may be repeated)\n"
+ " -d Set line as open drain\n"
+ " -s Set line as open source\n"
+ " -r Listen for rising edges\n"
+ " -f Listen for falling edges\n"
+ " -w Report the wall-clock time for events\n"
+ " -t Report the hardware timestamp for events\n"
+ " -b <n> Debounce the line with period n microseconds\n"
+ " [-c <n>] Do <n> loops (optional, infinite loop if not stated)\n"
+ " -? This helptext\n"
+ "\n"
+ "Example:\n"
+ "gpio-event-mon -n gpiochip0 -o 4 -r -f -b 10000\n"
+ );
+}
+
+#define EDGE_FLAGS \
+ (GPIO_V2_LINE_FLAG_EDGE_RISING | \
+ GPIO_V2_LINE_FLAG_EDGE_FALLING)
+
+int main(int argc, char **argv)
+{
+ const char *device_name = NULL;
+ unsigned int lines[GPIO_V2_LINES_MAX];
+ unsigned int num_lines = 0;
+ unsigned int loops = 0;
+ struct gpio_v2_line_config config;
+ int c, attr, i;
+ unsigned long debounce_period_us = 0;
+
+ memset(&config, 0, sizeof(config));
+ config.flags = GPIO_V2_LINE_FLAG_INPUT;
+ while ((c = getopt(argc, argv, "c:n:o:b:dsrfwt?")) != -1) {
+ switch (c) {
+ case 'c':
+ loops = strtoul(optarg, NULL, 10);
+ break;
+ case 'n':
+ device_name = optarg;
+ break;
+ case 'o':
+ if (num_lines >= GPIO_V2_LINES_MAX) {
+ print_usage();
+ return -1;
+ }
+ lines[num_lines] = strtoul(optarg, NULL, 10);
+ num_lines++;
+ break;
+ case 'b':
+ debounce_period_us = strtoul(optarg, NULL, 10);
+ break;
+ case 'd':
+ config.flags |= GPIO_V2_LINE_FLAG_OPEN_DRAIN;
+ break;
+ case 's':
+ config.flags |= GPIO_V2_LINE_FLAG_OPEN_SOURCE;
+ break;
+ case 'r':
+ config.flags |= GPIO_V2_LINE_FLAG_EDGE_RISING;
+ break;
+ case 'f':
+ config.flags |= GPIO_V2_LINE_FLAG_EDGE_FALLING;
+ break;
+ case 'w':
+ config.flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME;
+ break;
+ case 't':
+ config.flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE;
+ break;
+ case '?':
+ print_usage();
+ return -1;
+ }
+ }
+
+ if (debounce_period_us) {
+ attr = config.num_attrs;
+ config.num_attrs++;
+ for (i = 0; i < num_lines; i++)
+ gpiotools_set_bit(&config.attrs[attr].mask, i);
+ config.attrs[attr].attr.id = GPIO_V2_LINE_ATTR_ID_DEBOUNCE;
+ config.attrs[attr].attr.debounce_period_us = debounce_period_us;
+ }
+
+ if (!device_name || num_lines == 0) {
+ print_usage();
+ return -1;
+ }
+ if (!(config.flags & EDGE_FLAGS)) {
+ printf("No flags specified, listening on both rising and "
+ "falling edges\n");
+ config.flags |= EDGE_FLAGS;
+ }
+ return monitor_device(device_name, lines, num_lines, &config, loops);
+}
--- /dev/null
+// 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 <sys/socket.h>
+#include <sys/un.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;
+ struct sockaddr_un addr;
+ char swirr[] = "-\\|/";
+ int fd, cfd;
+ int ret;
+ int i, j;
+ unsigned int iteration = 0;
+
+ cfd = socket(AF_UNIX, SOCK_STREAM, 0);
+ memset(&addr, 0, sizeof(addr));
+
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, device_name, sizeof(addr.sun_path) - 1);
+
+ ret = connect(cfd, (const struct sockaddr *) &addr, sizeof(addr));
+ if (ret == -1) {
+ ret = -errno;
+ fprintf(stderr, "Failed to open %s with %s[%d]\n", device_name, strerror(ret), ret);
+ return ret;
+ }
+
+ memset(&config, 0, sizeof(config));
+ config.flags = GPIO_V2_LINE_FLAG_OUTPUT;
+
+ ret = gpiotools_request_line(cfd, 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, "%d", 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, "%d: %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);
+}
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * GPIO tools - helpers library for the GPIO tools
+ *
+ * Copyright (C) 2015 Linus Walleij
+ * Copyright (C) 2016 Bamvor Jian Zhang
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <linux/gpio.h>
+#include "gpio-utils.h"
+
+#define CONSUMER "gpio-utils"
+
+/**
+ * DOC: Operation of gpio
+ *
+ * Provide the api of gpiochip for chardev interface. There are two
+ * types of api. The first one provide as same function as each
+ * ioctl, including request and release for lines of gpio, read/write
+ * the value of gpio. If the user want to do lots of read and write of
+ * lines of gpio, user should use this type of api.
+ *
+ * The second one provide the easy to use api for user. Each of the
+ * following api will request gpio lines, do the operation and then
+ * release these lines.
+ */
+
+/**
+ * gpiotools_request_line() - request gpio lines in a gpiochip
+ * @device_name: The name of gpiochip without prefix "/dev/",
+ * such as "gpiochip0"
+ * @lines: An array desired lines, specified by offset
+ * index for the associated GPIO device.
+ * @num_lines: The number of lines to request.
+ * @config: The new config for requested gpio. Reference
+ * "linux/gpio.h" for config details.
+ * @consumer: The name of consumer, such as "sysfs",
+ * "powerkey". This is useful for other users to
+ * know who is using.
+ *
+ * Request gpio lines through the ioctl provided by chardev. User
+ * could call gpiotools_set_values() and gpiotools_get_values() to
+ * read and write respectively through the returned fd. Call
+ * gpiotools_release_line() to release these lines after that.
+ *
+ * Return: On success return the fd;
+ * On failure return the errno.
+ */
+int gpiotools_request_line(int fd, unsigned int *lines,
+ unsigned int num_lines,
+ struct gpio_v2_line_config *config,
+ const char *consumer)
+{
+ unsigned long val = GPIO_V2_GET_LINE_IOCTL;
+ struct gpio_v2_line_request req;
+ int i;
+ int ret;
+
+ memset(&req, 0, sizeof(req));
+ for (i = 0; i < num_lines; i++)
+ req.offsets[i] = lines[i];
+
+ req.config = *config;
+ strcpy(req.consumer, consumer);
+ req.num_lines = num_lines;
+
+ fprintf(stdout, "%s: sending 0x%lx\n", __func__, val);
+ ret = write(fd, &val, sizeof(val));
+ if (ret != sizeof(val)) {
+ ret = -errno;
+ fprintf(stderr, "Failed to issue %s (%d), %s\n",
+ "GPIO_GET_LINE_IOCTL", ret, strerror(errno));
+ goto exit;
+ }
+
+ ret = write(fd, &req, sizeof(req));
+ if (ret != sizeof(req)) {
+ ret = -errno;
+ fprintf(stderr, "Failed to write request %s (%d), %s\n",
+ "GPIO_GET_LINE_IOCTL", ret, strerror(errno));
+ }
+
+ req.fd = fd;
+
+exit:
+ return ret < 0 ? ret : req.fd;
+}
+
+/**
+ * gpiotools_set_values() - Set the value of gpio(s)
+ * @fd: The fd returned by
+ * gpiotools_request_line().
+ * @values: The array of values want to set.
+ *
+ * Return: On success return 0;
+ * On failure return the errno.
+ */
+int gpiotools_set_values(const int fd, struct gpio_v2_line_values *values)
+{
+ unsigned long val = GPIO_V2_LINE_SET_VALUES_IOCTL;
+ int ret;
+
+ ret = write(fd, &val, sizeof(val));
+ if (ret == -1) {
+ ret = -errno;
+ fprintf(stderr, "Failed to issue %s (%d), %s\n",
+ "GPIOHANDLE_SET_LINE_VALUES_IOCTL", ret,
+ strerror(errno));
+ }
+
+ ret = write(fd, values, sizeof(*values));
+ if (ret != sizeof(*values)) {
+ ret = -errno;
+ fprintf(stderr, "Failed to set values %s (%d), %s\n",
+ "GPIOHANDLE_SET_LINE_VALUES_IOCTL", ret,
+ strerror(errno));
+ }
+
+ return ret;
+}
+
+/**
+ * gpiotools_get_values() - Get the value of gpio(s)
+ * @fd: The fd returned by
+ * gpiotools_request_line().
+ * @values: The array of values get from hardware.
+ *
+ * Return: On success return 0;
+ * On failure return the errno.
+ */
+int gpiotools_get_values(const int fd, struct gpio_v2_line_values *values)
+{
+ unsigned long val = GPIO_V2_LINE_GET_VALUES_IOCTL;
+ int ret;
+
+ ret = write(fd, &val, sizeof(val));
+ if (ret != sizeof(val)) {
+ ret = -errno;
+ fprintf(stderr, "Failed to issue %s (%d), %s\n",
+ "GPIO_GET_LINE_IOCTL", ret, strerror(errno));
+ goto exit;
+ }
+
+ ret = recv(fd, &values, sizeof(*values), MSG_WAITALL);
+ if (ret != sizeof(*values)) {
+ ret = -errno;
+ fprintf(stderr, "Failed to issue %s (%d), %s\n",
+ "GPIO_GET_LINE_IOCTL", ret, strerror(errno));
+ }
+
+exit:
+ return ret;
+}
+
+/**
+ * gpiotools_release_line() - Release the line(s) of gpiochip
+ * @fd: The fd returned by
+ * gpiotools_request_line().
+ *
+ * Return: On success return 0;
+ * On failure return the errno.
+ */
+int gpiotools_release_line(const int fd)
+{
+ int ret;
+
+ ret = close(fd);
+ if (ret == -1) {
+ perror("Failed to close GPIO LINE device file");
+ ret = -errno;
+ }
+
+ return ret;
+}
+
+/**
+ * gpiotools_get() - Get value from specific line
+ * @device_name: The name of gpiochip without prefix "/dev/",
+ * such as "gpiochip0"
+ * @line: number of line, such as 2.
+ *
+ * Return: On success return 0;
+ * On failure return the errno.
+ */
+int gpiotools_get(const char *device_name, unsigned int line)
+{
+ int ret;
+ unsigned int value;
+ unsigned int lines[] = {line};
+
+ ret = gpiotools_gets(device_name, lines, 1, &value);
+ if (ret)
+ return ret;
+ return value;
+}
+
+
+/**
+ * gpiotools_gets() - Get values from specific lines.
+ * @device_name: The name of gpiochip without prefix "/dev/",
+ * such as "gpiochip0".
+ * @lines: An array desired lines, specified by offset
+ * index for the associated GPIO device.
+ * @num_lines: The number of lines to request.
+ * @values: The array of values get from gpiochip.
+ *
+ * Return: On success return 0;
+ * On failure return the errno.
+ */
+int gpiotools_gets(const char *device_name, unsigned int *lines,
+ unsigned int num_lines, unsigned int *values)
+{
+ int fd, i;
+ int ret;
+ int ret_close;
+ struct gpio_v2_line_config config;
+ struct gpio_v2_line_values lv;
+
+ memset(&config, 0, sizeof(config));
+ config.flags = GPIO_V2_LINE_FLAG_INPUT;
+ ret = gpiotools_request_line(device_name, lines, num_lines,
+ &config, CONSUMER);
+ if (ret < 0)
+ return ret;
+
+ fd = ret;
+ for (i = 0; i < num_lines; i++)
+ gpiotools_set_bit(&lv.mask, i);
+ ret = gpiotools_get_values(fd, &lv);
+ if (!ret)
+ for (i = 0; i < num_lines; i++)
+ values[i] = gpiotools_test_bit(lv.bits, i);
+ ret_close = gpiotools_release_line(fd);
+ return ret < 0 ? ret : ret_close;
+}
+
+/**
+ * gpiotools_set() - Set value to specific line
+ * @device_name: The name of gpiochip without prefix "/dev/",
+ * such as "gpiochip0"
+ * @line: number of line, such as 2.
+ * @value: The value of gpio, must be 0(low) or 1(high).
+ *
+ * Return: On success return 0;
+ * On failure return the errno.
+ */
+int gpiotools_set(const char *device_name, unsigned int line,
+ unsigned int value)
+{
+ unsigned int lines[] = {line};
+
+ return gpiotools_sets(device_name, lines, 1, &value);
+}
+
+/**
+ * gpiotools_sets() - Set values to specific lines.
+ * @device_name: The name of gpiochip without prefix "/dev/",
+ * such as "gpiochip0".
+ * @lines: An array desired lines, specified by offset
+ * index for the associated GPIO device.
+ * @num_lines: The number of lines to request.
+ * @values: The array of values set to gpiochip, must be
+ * 0(low) or 1(high).
+ *
+ * Return: On success return 0;
+ * On failure return the errno.
+ */
+int gpiotools_sets(const char *device_name, unsigned int *lines,
+ unsigned int num_lines, unsigned int *values)
+{
+ int ret, i;
+ struct gpio_v2_line_config config;
+
+ memset(&config, 0, sizeof(config));
+ config.flags = GPIO_V2_LINE_FLAG_OUTPUT;
+ config.num_attrs = 1;
+ config.attrs[0].attr.id = GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES;
+ for (i = 0; i < num_lines; i++) {
+ gpiotools_set_bit(&config.attrs[0].mask, i);
+ gpiotools_assign_bit(&config.attrs[0].attr.values,
+ i, values[i]);
+ }
+ ret = gpiotools_request_line(device_name, lines, num_lines,
+ &config, CONSUMER);
+ if (ret < 0)
+ return ret;
+
+ return gpiotools_release_line(ret);
+}
--- /dev/null
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * GPIO tools - utility helpers library for the GPIO tools
+ *
+ * Copyright (C) 2015 Linus Walleij
+ *
+ * Portions copied from iio_utils and lssio:
+ * Copyright (c) 2010 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
+ * Copyright (c) 2008 Jonathan Cameron
+ * *
+ */
+#ifndef _GPIO_UTILS_H_
+#define _GPIO_UTILS_H_
+
+#include <stdbool.h>
+#include <string.h>
+#include <linux/types.h>
+
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+static inline int check_prefix(const char *str, const char *prefix)
+{
+ return strlen(str) > strlen(prefix) &&
+ strncmp(str, prefix, strlen(prefix)) == 0;
+}
+
+int gpiotools_request_line(int fd,
+ unsigned int *lines,
+ unsigned int num_lines,
+ struct gpio_v2_line_config *config,
+ const char *consumer);
+int gpiotools_set_values(const int fd, struct gpio_v2_line_values *values);
+int gpiotools_get_values(const int fd, struct gpio_v2_line_values *values);
+int gpiotools_release_line(const int fd);
+
+int gpiotools_get(const char *device_name, unsigned int line);
+int gpiotools_gets(const char *device_name, unsigned int *lines,
+ unsigned int num_lines, unsigned int *values);
+int gpiotools_set(const char *device_name, unsigned int line,
+ unsigned int value);
+int gpiotools_sets(const char *device_name, unsigned int *lines,
+ unsigned int num_lines, unsigned int *values);
+
+/* helper functions for gpio_v2_line_values bits */
+static inline void gpiotools_set_bit(__u64 *b, int n)
+{
+ *b |= _BITULL(n);
+}
+
+static inline void gpiotools_change_bit(__u64 *b, int n)
+{
+ *b ^= _BITULL(n);
+}
+
+static inline void gpiotools_clear_bit(__u64 *b, int n)
+{
+ *b &= ~_BITULL(n);
+}
+
+static inline int gpiotools_test_bit(__u64 b, int n)
+{
+ return !!(b & _BITULL(n));
+}
+
+static inline void gpiotools_assign_bit(__u64 *b, int n, bool value)
+{
+ if (value)
+ gpiotools_set_bit(b, n);
+ else
+ gpiotools_clear_bit(b, n);
+}
+
+#endif /* _GPIO_UTILS_H_ */
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * lsgpio - example on how to list the GPIO lines on a system
+ *
+ * Copyright (C) 2023 Nikita Shubin
+ *
+ * derivative:
+ * linux/tools/gpio/lsgpio.c
+ * 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 <sys/socket.h>
+#include <sys/un.h>
+
+#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(0[arr]))
+
+
+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,
+ },
+ {
+ .name = "clock-realtime",
+ .mask = GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME,
+ },
+};
+
+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[i].debounce_period_us);
+ }
+}
+
+
+
+int list_device(const char *device_name)
+{
+ struct sockaddr_un addr;
+ struct gpiochip_info cinfo;
+ char *chrdev_name;
+ int fd;
+ int ret;
+ int i;
+
+ if (!device_name)
+ return -EINVAL;
+
+ ret = asprintf(&chrdev_name, "%s", device_name);
+ if (ret < 0)
+ return -ENOMEM;
+
+ fd = socket(AF_UNIX, SOCK_STREAM, 0);
+ memset(&addr, 0, sizeof(addr));
+
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, device_name, sizeof(addr.sun_path) - 1);
+
+ ret = connect(fd, (const struct sockaddr *) &addr, sizeof(addr));
+ if (ret == -1) {
+ ret = -errno;
+ fprintf(stderr, "Failed to open %s with %d\n", chrdev_name, ret);
+ }
+
+ {
+ unsigned long val = GPIO_GET_CHIPINFO_IOCTL;
+ fprintf(stdout, "sending 0x%lx\n", val);
+ ret = write(fd, &val, sizeof(val));
+ }
+
+ ret = read(fd, &cinfo, sizeof(cinfo));
+
+ if (ret != sizeof(cinfo))
+ perror("Reading cinfo failed");
+
+ fprintf(stdout, "GPIO chip: %s, \"%s\", %u GPIO lines\n",
+ cinfo.name, cinfo.label, cinfo.lines);
+
+ /* Loop over the lines and print info */
+ for (i = 0; i < cinfo.lines; i++) {
+ unsigned long val = GPIO_V2_GET_LINEINFO_IOCTL;
+ struct gpio_v2_line_info linfo;
+
+ memset(&linfo, 0, sizeof(linfo));
+ linfo.offset = i;
+
+ ret = write(fd, &val, sizeof(val));
+ ret = write(fd, &linfo, sizeof(linfo));
+
+ if (ret == -1) {
+ ret = -errno;
+ perror("Failed to issue LINEINFO IOCTL\n");
+ goto exit_close_error;
+ }
+
+ ret = read(fd, &linfo, sizeof(linfo));
+
+ 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, "\n");
+
+ }
+
+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]...\n"
+ "List GPIO chips, lines and states\n"
+ " -n <name> List GPIOs on a named device\n"
+ " -? This helptext\n"
+ );
+}
+
+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;
+ }
+ }
+
+ return list_device(device_name);
+}
projects / qemu-gpiodev / qemu-gpio-tools / commitdiff