ctxless: provide new event monitor

Current implementation of gpiod_ctxless_event_loop() (and its variant
for multiple lines) always requests GPIO lines for listening for both
rising and falling edge events. This causes a problem when the
underlying hardware doesn't allow this.

It can e.g. result in the following error raised by the interrupt
controller:

  genirq: Setting trigger mode 3 for irq 107 failed (kempld_irq_set_type+0x0/0x130 [gpio_kempld])

For the sake of backward compatibility we're leaving the old
implementation in place and provide two new routines that that take an
additional parameter allowing users to specify the events libgpiod
should listen for.

Signed-off-by: Bartosz Golaszewski <bartekgola@gmail.com>

diff --git a/include/gpiod.h b/include/gpiod.h
index 5ae45aa9a23cd400556f97ca40ff5be29a8c42e1..513b9e73dd4c38459852c0cc4d38a7b10a644123 100644 (file)
--- a/include/gpiod.h
+++ b/include/gpiod.h
@@ -148,6 +148,18 @@ int gpiod_ctxless_set_value_multiple(const char *device,
                                     gpiod_ctxless_set_value_cb cb,
                                     void *data) GPIOD_API;
 
+/**
+ * @brief Event types that the ctxless event monitor can wait for.
+ */
+enum {
+       /**< Wait for rising edge events only. */
+       GPIOD_CTXLESS_EVENT_RISING_EDGE = 1,
+       /**< Wait for falling edge events only. */
+       GPIOD_CTXLESS_EVENT_FALLING_EDGE,
+       /**< Wait for both types of events. */
+       GPIOD_CTXLESS_EVENT_BOTH_EDGES,
+};
+
 /**
  * @brief Event types that can be passed to the ctxless event callback.
  */
@@ -286,6 +298,69 @@ int gpiod_ctxless_event_loop_multiple(const char *device,
                                      gpiod_ctxless_event_handle_cb event_cb,
                                      void *data) GPIOD_API;
 
+/**
+ * @brief Wait for events on a single GPIO line.
+ * @param device Name, path, number or label of the gpiochip.
+ * @param event_type Type of events to listen for.
+ * @param offset GPIO line offset to monitor.
+ * @param active_low The active state of this line - true if low.
+ * @param consumer Name of the consumer.
+ * @param timeout Maximum wait time for each iteration.
+ * @param poll_cb Callback function to call when waiting for events.
+ * @param event_cb Callback function to call for each line event.
+ * @param data User data passed to the callback.
+ * @return 0 if no errors were encountered, -1 if an error occurred.
+ * @note The way the ctxless event loop works is described in detail in
+ *       ::gpiod_ctxless_event_monitor_multiple - this is just a wrapper aound
+ *       this routine which calls it for a single GPIO line.
+ */
+int gpiod_ctxless_event_monitor(const char *device, int event_type,
+                               unsigned int offset, bool active_low,
+                               const char *consumer,
+                               const struct timespec *timeout,
+                               gpiod_ctxless_event_poll_cb poll_cb,
+                               gpiod_ctxless_event_handle_cb event_cb,
+                               void *data) GPIOD_API;
+
+/**
+ * @brief Wait for events on multiple GPIO lines.
+ * @param device Name, path, number or label of the gpiochip.
+ * @param event_type Type of events to listen for.
+ * @param offsets Array of GPIO line offsets to monitor.
+ * @param num_lines Number of lines to monitor.
+ * @param active_low The active state of this line - true if low.
+ * @param consumer Name of the consumer.
+ * @param timeout Maximum wait time for each iteration.
+ * @param poll_cb Callback function to call when waiting for events. Can
+ *                be NULL.
+ * @param event_cb Callback function to call on event occurrence.
+ * @param data User data passed to the callback.
+ * @return 0 no errors were encountered, -1 if an error occurred.
+ * @note The poll callback can be NULL in which case the routine will fall
+ *       back to a basic, ppoll() based callback.
+ *
+ * Internally this routine opens the GPIO chip, requests the set of lines for
+ * the type of events specified in the event_type paramter and calls the
+ * polling callback in a loop. The role of the polling callback is to detect
+ * input events on a set of file descriptors and notify the caller about the
+ * fds ready for reading.
+ *
+ * The ctxless event loop then reads each queued event from marked descriptors
+ * and calls the event callback. Both callbacks can stop the loop at any
+ * point.
+ *
+ * The poll_cb argument can be NULL in which case the function falls back to
+ * a default, ppoll() based callback.
+ */
+int gpiod_ctxless_event_monitor_multiple(
+                       const char *device, int event_type,
+                       const unsigned int *offsets,
+                       unsigned int num_lines, bool active_low,
+                       const char *consumer, const struct timespec *timeout,
+                       gpiod_ctxless_event_poll_cb poll_cb,
+                       gpiod_ctxless_event_handle_cb event_cb,
+                       void *data) GPIOD_API;
+
 /**
  * @brief Determine the chip name and line offset of a line with given name.
  * @param name The name of the GPIO line to lookup.

diff --git a/src/lib/ctxless.c b/src/lib/ctxless.c
index f3545cf5b4aee3e01f8a71e90acb4e7d9ee9a8b1..0009504e982a65ade0ccbaf7398823391a99c8d0 100644 (file)
--- a/src/lib/ctxless.c
+++ b/src/lib/ctxless.c
@@ -181,9 +181,10 @@ int gpiod_ctxless_event_loop(const char *device, unsigned int offset,
                             gpiod_ctxless_event_handle_cb event_cb,
                             void *data)
 {
-       return gpiod_ctxless_event_loop_multiple(device, &offset, 1,
-                                                active_low, consumer, timeout,
-                                                poll_cb, event_cb, data);
+       return gpiod_ctxless_event_monitor(device,
+                                          GPIOD_CTXLESS_EVENT_BOTH_EDGES,
+                                          offset, active_low, consumer,
+                                          timeout, poll_cb, event_cb, data);
 }
 
 int gpiod_ctxless_event_loop_multiple(const char *device,
@@ -194,11 +195,42 @@ int gpiod_ctxless_event_loop_multiple(const char *device,
                                      gpiod_ctxless_event_poll_cb poll_cb,
                                      gpiod_ctxless_event_handle_cb event_cb,
                                      void *data)
+{
+       return gpiod_ctxless_event_monitor_multiple(
+                               device, GPIOD_CTXLESS_EVENT_BOTH_EDGES,
+                               offsets, num_lines, active_low, consumer,
+                               timeout, poll_cb, event_cb, data);
+}
+
+int gpiod_ctxless_event_monitor(const char *device, int event_type,
+                               unsigned int offset, bool active_low,
+                               const char *consumer,
+                               const struct timespec *timeout,
+                               gpiod_ctxless_event_poll_cb poll_cb,
+                               gpiod_ctxless_event_handle_cb event_cb,
+                               void *data)
+{
+       return gpiod_ctxless_event_monitor_multiple(device, event_type,
+                                                   &offset, 1, active_low,
+                                                   consumer, timeout,
+                                                   poll_cb, event_cb, data);
+}
+
+int gpiod_ctxless_event_monitor_multiple(
+                       const char *device, int event_type,
+                       const unsigned int *offsets,
+                       unsigned int num_lines, bool active_low,
+                       const char *consumer,
+                       const struct timespec *timeout,
+                       gpiod_ctxless_event_poll_cb poll_cb,
+                       gpiod_ctxless_event_handle_cb event_cb,
+                       void *data)
 {
        struct gpiod_ctxless_event_poll_fd fds[GPIOD_LINE_BULK_MAX_LINES];
-       int rv, ret, flags, evtype, cnt;
+       struct gpiod_line_request_config conf;
        struct gpiod_line_event event;
        struct gpiod_line_bulk bulk;
+       int rv, ret, evtype, cnt;
        struct gpiod_chip *chip;
        struct gpiod_line *line;
        unsigned int i;
@@ -227,10 +259,22 @@ int gpiod_ctxless_event_loop_multiple(const char *device,
                gpiod_line_bulk_add(&bulk, line);
        }
 
-       flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
+       conf.flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
+       conf.consumer = consumer;
+
+       if (event_type == GPIOD_CTXLESS_EVENT_RISING_EDGE) {
+               conf.request_type = GPIOD_LINE_REQUEST_EVENT_RISING_EDGE;
+       } else if (event_type == GPIOD_CTXLESS_EVENT_FALLING_EDGE) {
+               conf.request_type = GPIOD_LINE_REQUEST_EVENT_FALLING_EDGE;
+       } else if (event_type == GPIOD_CTXLESS_EVENT_BOTH_EDGES) {
+               conf.request_type = GPIOD_LINE_REQUEST_EVENT_BOTH_EDGES;
+       } else {
+               errno = -EINVAL;
+               ret = -1;
+               goto out;
+       }
 
-       rv = gpiod_line_request_bulk_both_edges_events_flags(&bulk,
-                                                             consumer, flags);
+       rv = gpiod_line_request_bulk(&bulk, &conf, NULL);
        if (rv) {
                ret = -1;
                goto out;