[libgpiod,02/19] API: add support for bias flags
diff mbox series

Message ID 20191115144355.975-3-warthog618@gmail.com
State New
Headers show
Series
  • Add support for bias flags and SET_CONFIG
Related show

Commit Message

Kent Gibson Nov. 15, 2019, 2:43 p.m. UTC
Extend the libgpiod API to support the bias flags recently added to the
kernel GPIO uAPI.  The core change is the addition of
GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE, GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP
and GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN flags to be passed into
line_request functions, and the addition of gpiod_line_bias to return the
bias state of lines.

Extended variants of the ctxless functions that accept an active_low flag
are added to also accept other flags. The variant names add a "_ext"
suffix to the name of the original function.

Based on initial work by Drew Fustini <drew@pdp7.com>.

Signed-off-by: Kent Gibson <warthog618@gmail.com>
---
 include/gpiod.h | 184 ++++++++++++++++++++++++++++++++++++++++++++++++
 lib/core.c      |  32 ++++++---
 lib/ctxless.c   | 115 +++++++++++++++++++++++++++---
 3 files changed, 313 insertions(+), 18 deletions(-)

Comments

Bartosz Golaszewski Nov. 18, 2019, 1:51 p.m. UTC | #1
pt., 15 lis 2019 o 15:44 Kent Gibson <warthog618@gmail.com> napisał(a):
>
> Extend the libgpiod API to support the bias flags recently added to the
> kernel GPIO uAPI.  The core change is the addition of
> GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE, GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP
> and GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN flags to be passed into
> line_request functions, and the addition of gpiod_line_bias to return the
> bias state of lines.
>
> Extended variants of the ctxless functions that accept an active_low flag
> are added to also accept other flags. The variant names add a "_ext"
> suffix to the name of the original function.
>
> Based on initial work by Drew Fustini <drew@pdp7.com>.
>
> Signed-off-by: Kent Gibson <warthog618@gmail.com>

Hi Kent,

this looks good, just a couple nits. I'd change the subject line to
"core: add support for bias flags". Also: how about moving the flags
argument to the last position in all the ctxless extended variants, so
that they keep the same signature *except* for the appended new
argument?

Bart



> ---
>  include/gpiod.h | 184 ++++++++++++++++++++++++++++++++++++++++++++++++
>  lib/core.c      |  32 ++++++---
>  lib/ctxless.c   | 115 +++++++++++++++++++++++++++---
>  3 files changed, 313 insertions(+), 18 deletions(-)
>
> diff --git a/include/gpiod.h b/include/gpiod.h
> index 9860ea8..0f01cab 100644
> --- a/include/gpiod.h
> +++ b/include/gpiod.h
> @@ -84,6 +84,22 @@ struct gpiod_line_bulk;
>   * the need to use the gpiod_* structures or to keep track of resources.
>   */
>
> +/**
> + * @brief Miscellaneous GPIO flags.
> + */
> +enum {
> +       GPIOD_CTXLESS_FLAG_OPEN_DRAIN           = GPIOD_BIT(0),
> +       /**< The line is an open-drain port. */
> +       GPIOD_CTXLESS_FLAG_OPEN_SOURCE          = GPIOD_BIT(1),
> +       /**< The line is an open-source port. */
> +       GPIOD_CTXLESS_FLAG_BIAS_DISABLE         = GPIOD_BIT(2),
> +       /**< The line has neither either pull-up nor pull-down resistor */
> +       GPIOD_CTXLESS_FLAG_BIAS_PULL_DOWN       = GPIOD_BIT(3),
> +       /**< The line has pull-down resistor enabled */
> +       GPIOD_CTXLESS_FLAG_BIAS_PULL_UP         = GPIOD_BIT(4),
> +       /**< The line has pull-up resistor enabled */
> +};
> +
>  /**
>   * @brief Read current value from a single GPIO line.
>   * @param device Name, path, number or label of the gpiochip.
> @@ -95,6 +111,19 @@ struct gpiod_line_bulk;
>  int gpiod_ctxless_get_value(const char *device, unsigned int offset,
>                             bool active_low, const char *consumer) GPIOD_API;
>
> +/**
> + * @brief Read current value from a single GPIO line.
> + * @param device Name, path, number or label of the gpiochip.
> + * @param offset Offset of the GPIO line.
> + * @param active_low The active state of this line - true if low.
> + * @param flags The flags for the line.
> + * @param consumer Name of the consumer.
> + * @return 0 or 1 (GPIO value) if the operation succeeds, -1 on error.
> + */
> +int gpiod_ctxless_get_value_ext(const char *device, unsigned int offset,
> +                               bool active_low, int flags,
> +                               const char *consumer) GPIOD_API;
> +
>  /**
>   * @brief Read current values from a set of GPIO lines.
>   * @param device Name, path, number or label of the gpiochip.
> @@ -110,6 +139,24 @@ int gpiod_ctxless_get_value_multiple(const char *device,
>                                      unsigned int num_lines, bool active_low,
>                                      const char *consumer) GPIOD_API;
>
> +/**
> + * @brief Read current values from a set of GPIO lines.
> + * @param device Name, path, number or label of the gpiochip.
> + * @param offsets Array of offsets of lines whose values should be read.
> + * @param values Buffer in which the values will be stored.
> + * @param num_lines Number of lines, must be > 0.
> + * @param active_low The active state of this line - true if low.
> + * @param flags The flags for the lines.
> + * @param consumer Name of the consumer.
> + * @return 0 if the operation succeeds, -1 on error.
> + */
> +int gpiod_ctxless_get_value_multiple_ext(const char *device,
> +                                        const unsigned int *offsets,
> +                                        int *values,
> +                                        unsigned int num_lines,
> +                                        bool active_low, int flags,
> +                                        const char *consumer) GPIOD_API;
> +
>  /**
>   * @brief Simple set value callback signature.
>   */
> @@ -133,6 +180,26 @@ int gpiod_ctxless_set_value(const char *device, unsigned int offset, int value,
>                             gpiod_ctxless_set_value_cb cb,
>                             void *data) GPIOD_API;
>
> +/**
> + * @brief Set value of a single GPIO line.
> + * @param device Name, path, number or label of the gpiochip.
> + * @param offset The offset of the GPIO line.
> + * @param value New value (0 or 1).
> + * @param active_low The active state of this line - true if low.
> + * @param flags The flags for the line.
> + * @param consumer Name of the consumer.
> + * @param cb Optional callback function that will be called right after setting
> + *           the value. Users can use this, for example, to pause the execution
> + *           after toggling a GPIO.
> + * @param data Optional user data that will be passed to the callback function.
> + * @return 0 if the operation succeeds, -1 on error.
> + */
> +int gpiod_ctxless_set_value_ext(const char *device, unsigned int offset,
> +                               int value, bool active_low, int flags,
> +                               const char *consumer,
> +                               gpiod_ctxless_set_value_cb cb,
> +                               void *data) GPIOD_API;
> +
>  /**
>   * @brief Set values of multiple GPIO lines.
>   * @param device Name, path, number or label of the gpiochip.
> @@ -153,6 +220,29 @@ int gpiod_ctxless_set_value_multiple(const char *device,
>                                      gpiod_ctxless_set_value_cb cb,
>                                      void *data) GPIOD_API;
>
> +/**
> + * @brief Set values of multiple GPIO lines.
> + * @param device Name, path, number or label of the gpiochip.
> + * @param offsets Array of offsets of lines the values of which should be set.
> + * @param values Array of integers containing new values.
> + * @param num_lines Number of lines, must be > 0.
> + * @param active_low The active state of this line - true if low.
> + * @param flags The flags for the lines.
> + * @param consumer Name of the consumer.
> + * @param cb Optional callback function that will be called right after setting
> + *           all values. Works the same as in ::gpiod_ctxless_set_value.
> + * @param data Optional user data that will be passed to the callback function.
> + * @return 0 if the operation succeeds, -1 on error.
> + */
> +int gpiod_ctxless_set_value_multiple_ext(const char *device,
> +                                        const unsigned int *offsets,
> +                                        const int *values,
> +                                        unsigned int num_lines,
> +                                        bool active_low, int flags,
> +                                        const char *consumer,
> +                                        gpiod_ctxless_set_value_cb cb,
> +                                        void *data) GPIOD_API;
> +
>  /**
>   * @brief Event types that the ctxless event monitor can wait for.
>   */
> @@ -327,6 +417,31 @@ int gpiod_ctxless_event_monitor(const char *device, int event_type,
>                                 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 flags The flags for the line.
> + * @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_ext(const char *device, int event_type,
> +                                   unsigned int offset, bool active_low,
> +                                   int flags, 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.
> @@ -366,6 +481,47 @@ int gpiod_ctxless_event_monitor_multiple(
>                         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 flags The flags for the lines.
> + * @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 parameter 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_ext(
> +                       const char *device, int event_type,
> +                       const unsigned int *offsets,
> +                       unsigned int num_lines, bool active_low, int flags,
> +                       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.
> @@ -658,6 +814,20 @@ enum {
>         /**< The active state of a GPIO is active-low. */
>  };
>
> +/**
> + * @brief Possible internal bias settings.
> + */
> +enum {
> +       GPIOD_LINE_BIAS_AS_IS = 1,
> +       /**< The internal bias state is unknown. */
> +       GPIOD_LINE_BIAS_DISABLE,
> +       /**< The internal bias is disabled. */
> +       GPIOD_LINE_BIAS_PULL_UP,
> +       /**< The internal pull-up bias is enabled. */
> +       GPIOD_LINE_BIAS_PULL_DOWN,
> +       /**< The internal pull-down bias is enabled. */
> +};
> +
>  /**
>   * @brief Read the GPIO line offset.
>   * @param line GPIO line object.
> @@ -697,6 +867,14 @@ int gpiod_line_direction(struct gpiod_line *line) GPIOD_API;
>   */
>  int gpiod_line_active_state(struct gpiod_line *line) GPIOD_API;
>
> +/**
> + * @brief Read the GPIO line bias setting.
> + * @param line GPIO line object.
> + * @return Returns GPIOD_LINE_BIAS_PULL_UP, GPIOD_LINE_BIAS_PULL_DOWN,
> + *         GPIOD_LINE_BIAS_DISABLE or GPIOD_LINE_BIAS_AS_IS.
> + */
> +int gpiod_line_bias(struct gpiod_line *line) GPIOD_API;
> +
>  /**
>   * @brief Check if the line is currently in use.
>   * @param line GPIO line object.
> @@ -792,6 +970,12 @@ enum {
>         /**< The line is an open-source port. */
>         GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW      = GPIOD_BIT(2),
>         /**< The active state of the line is low (high is the default). */
> +       GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE    = GPIOD_BIT(3),
> +       /**< The line has neither either pull-up nor pull-down resistor */
> +       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN  = GPIOD_BIT(4),
> +       /**< The line has pull-down resistor enabled */
> +       GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP    = GPIOD_BIT(5),
> +       /**< The line has pull-up resistor enabled */
>  };
>
>  /**
> diff --git a/lib/core.c b/lib/core.c
> index f05e595..9b7d88f 100644
> --- a/lib/core.c
> +++ b/lib/core.c
> @@ -36,9 +36,7 @@ struct gpiod_line {
>         unsigned int offset;
>         int direction;
>         int active_state;
> -       bool used;
> -       bool open_source;
> -       bool open_drain;
> +       __u32 flags;
>
>         int state;
>         bool needs_update;
> @@ -359,19 +357,31 @@ int gpiod_line_active_state(struct gpiod_line *line)
>         return line->active_state;
>  }
>
> +int gpiod_line_bias(struct gpiod_line *line)
> +{
> +       if (line->flags & GPIOLINE_FLAG_BIAS_DISABLE)
> +               return GPIOD_LINE_BIAS_DISABLE;
> +       if (line->flags & GPIOLINE_FLAG_BIAS_PULL_UP)
> +               return GPIOD_LINE_BIAS_PULL_UP;
> +       if (line->flags & GPIOLINE_FLAG_BIAS_PULL_DOWN)
> +               return GPIOD_LINE_BIAS_PULL_DOWN;
> +
> +       return GPIOD_LINE_BIAS_AS_IS;
> +}
> +
>  bool gpiod_line_is_used(struct gpiod_line *line)
>  {
> -       return line->used;
> +       return line->flags & GPIOLINE_FLAG_KERNEL;
>  }
>
>  bool gpiod_line_is_open_drain(struct gpiod_line *line)
>  {
> -       return line->open_drain;
> +       return line->flags & GPIOLINE_FLAG_OPEN_DRAIN;
>  }
>
>  bool gpiod_line_is_open_source(struct gpiod_line *line)
>  {
> -       return line->open_source;
> +       return line->flags & GPIOLINE_FLAG_OPEN_SOURCE;
>  }
>
>  bool gpiod_line_needs_update(struct gpiod_line *line)
> @@ -398,9 +408,7 @@ int gpiod_line_update(struct gpiod_line *line)
>                                                 ? GPIOD_LINE_ACTIVE_STATE_LOW
>                                                 : GPIOD_LINE_ACTIVE_STATE_HIGH;
>
> -       line->used = info.flags & GPIOLINE_FLAG_KERNEL;
> -       line->open_drain = info.flags & GPIOLINE_FLAG_OPEN_DRAIN;
> -       line->open_source = info.flags & GPIOLINE_FLAG_OPEN_SOURCE;
> +       line->flags = info.flags;
>
>         strncpy(line->name, info.name, sizeof(line->name));
>         strncpy(line->consumer, info.consumer, sizeof(line->consumer));
> @@ -473,6 +481,12 @@ static __u32 line_request_flag_to_gpio_handleflag(int flags)
>                 hflags |= GPIOHANDLE_REQUEST_OPEN_SOURCE;
>         if (flags & GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW)
>                 hflags |= GPIOHANDLE_REQUEST_ACTIVE_LOW;
> +       if (flags & GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE)
> +               hflags |= GPIOHANDLE_REQUEST_BIAS_DISABLE;
> +       if (flags & GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN)
> +               hflags |= GPIOHANDLE_REQUEST_BIAS_PULL_DOWN;
> +       if (flags & GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP)
> +               hflags |= GPIOHANDLE_REQUEST_BIAS_PULL_UP;
>
>         return hflags;
>  }
> diff --git a/lib/ctxless.c b/lib/ctxless.c
> index ba85018..44f1872 100644
> --- a/lib/ctxless.c
> +++ b/lib/ctxless.c
> @@ -14,6 +14,26 @@
>  #include <stdio.h>
>  #include <string.h>
>
> +static int ctxless_flags_to_line_request_flags(bool active_low, int flags)
> +{
> +       int lflags = 0;
> +
> +       if (active_low)
> +               lflags |= GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW;
> +       if (flags & GPIOD_CTXLESS_FLAG_OPEN_DRAIN)
> +               lflags |= GPIOD_LINE_REQUEST_FLAG_OPEN_DRAIN;
> +       if (flags & GPIOD_CTXLESS_FLAG_OPEN_SOURCE)
> +               lflags |= GPIOD_LINE_REQUEST_FLAG_OPEN_SOURCE;
> +       if (flags & GPIOD_CTXLESS_FLAG_BIAS_DISABLE)
> +               lflags |= GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE;
> +       if (flags & GPIOD_CTXLESS_FLAG_BIAS_PULL_UP)
> +               lflags |= GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP;
> +       if (flags & GPIOD_CTXLESS_FLAG_BIAS_PULL_DOWN)
> +               lflags |= GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN;
> +
> +       return lflags;
> +}
> +
>  int gpiod_ctxless_get_value(const char *device, unsigned int offset,
>                             bool active_low, const char *consumer)
>  {
> @@ -27,16 +47,45 @@ int gpiod_ctxless_get_value(const char *device, unsigned int offset,
>         return value;
>  }
>
> +int gpiod_ctxless_get_value_ext(const char *device, unsigned int offset,
> +                               bool active_low, int flags,
> +                               const char *consumer)
> +{
> +       int value, rv;
> +
> +       rv = gpiod_ctxless_get_value_multiple_ext(device, &offset, &value, 1,
> +                                                 active_low, flags, consumer);
> +       if (rv < 0)
> +               return rv;
> +
> +       return value;
> +}
> +
>  int gpiod_ctxless_get_value_multiple(const char *device,
>                                      const unsigned int *offsets, int *values,
>                                      unsigned int num_lines, bool active_low,
>                                      const char *consumer)
> +{
> +       int rv;
> +
> +       rv = gpiod_ctxless_get_value_multiple_ext(device, offsets, values,
> +                                                 num_lines, active_low, 0,
> +                                                 consumer);
> +       return rv;
> +}
> +
> +int gpiod_ctxless_get_value_multiple_ext(const char *device,
> +                                        const unsigned int *offsets,
> +                                        int *values,
> +                                        unsigned int num_lines,
> +                                        bool active_low, int flags,
> +                                        const char *consumer)
>  {
>         struct gpiod_line_bulk bulk;
>         struct gpiod_chip *chip;
>         struct gpiod_line *line;
>         unsigned int i;
> -       int rv, flags;
> +       int rv, lflags;
>
>         if (!num_lines || num_lines > GPIOD_LINE_BULK_MAX_LINES) {
>                 errno = EINVAL;
> @@ -59,9 +108,8 @@ int gpiod_ctxless_get_value_multiple(const char *device,
>                 gpiod_line_bulk_add(&bulk, line);
>         }
>
> -       flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
> -
> -       rv = gpiod_line_request_bulk_input_flags(&bulk, consumer, flags);
> +       lflags = ctxless_flags_to_line_request_flags(active_low, flags);
> +       rv = gpiod_line_request_bulk_input_flags(&bulk, consumer, lflags);
>         if (rv < 0) {
>                 gpiod_chip_close(chip);
>                 return -1;
> @@ -83,17 +131,39 @@ int gpiod_ctxless_set_value(const char *device, unsigned int offset, int value,
>                                                 active_low, consumer, cb, data);
>  }
>
> +int gpiod_ctxless_set_value_ext(const char *device, unsigned int offset,
> +                               int value, bool active_low, int flags,
> +                               const char *consumer,
> +                               gpiod_ctxless_set_value_cb cb, void *data)
> +{
> +       return gpiod_ctxless_set_value_multiple_ext(device, &offset, &value,
> +                                                   1, active_low, flags,
> +                                                   consumer, cb, data);
> +}
> +
>  int gpiod_ctxless_set_value_multiple(const char *device,
>                                      const unsigned int *offsets,
>                                      const int *values, unsigned int num_lines,
>                                      bool active_low, const char *consumer,
>                                      gpiod_ctxless_set_value_cb cb, void *data)
> +{
> +       return gpiod_ctxless_set_value_multiple_ext(device, offsets, values,
> +                                                   num_lines, active_low,
> +                                                   0, consumer, cb, data);
> +}
> +
> +int gpiod_ctxless_set_value_multiple_ext(
> +                       const char *device,
> +                       const unsigned int *offsets,
> +                       const int *values, unsigned int num_lines,
> +                       bool active_low, int flags, const char *consumer,
> +                       gpiod_ctxless_set_value_cb cb, void *data)
>  {
>         struct gpiod_line_bulk bulk;
>         struct gpiod_chip *chip;
>         struct gpiod_line *line;
>         unsigned int i;
> -       int rv, flags;
> +       int rv, lflags;
>
>         if (!num_lines || num_lines > GPIOD_LINE_BULK_MAX_LINES) {
>                 errno = EINVAL;
> @@ -116,10 +186,9 @@ int gpiod_ctxless_set_value_multiple(const char *device,
>                 gpiod_line_bulk_add(&bulk, line);
>         }
>
> -       flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
> -
> +       lflags = ctxless_flags_to_line_request_flags(active_low, flags);
>         rv = gpiod_line_request_bulk_output_flags(&bulk, consumer,
> -                                                 flags, values);
> +                                                 lflags, values);
>         if (rv < 0) {
>                 gpiod_chip_close(chip);
>                 return -1;
> @@ -216,6 +285,19 @@ int gpiod_ctxless_event_monitor(const char *device, int event_type,
>                                                     poll_cb, event_cb, data);
>  }
>
> +int gpiod_ctxless_event_monitor_ext(const char *device, int event_type,
> +                                   unsigned int offset, bool active_low,
> +                                   int flags, 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_ext(
> +                       device, event_type, &offset, 1, active_low,
> +                       flags, consumer, timeout, poll_cb, event_cb, data);
> +}
> +
>  int gpiod_ctxless_event_monitor_multiple(
>                         const char *device, int event_type,
>                         const unsigned int *offsets,
> @@ -225,6 +307,21 @@ int gpiod_ctxless_event_monitor_multiple(
>                         gpiod_ctxless_event_poll_cb poll_cb,
>                         gpiod_ctxless_event_handle_cb event_cb,
>                         void *data)
> +{
> +       return gpiod_ctxless_event_monitor_multiple_ext(
> +                       device, event_type, offsets,
> +                       num_lines, active_low, 0, consumer, timeout,
> +                       poll_cb, event_cb, data);
> +}
> +
> +int gpiod_ctxless_event_monitor_multiple_ext(
> +                       const char *device, int event_type,
> +                       const unsigned int *offsets,
> +                       unsigned int num_lines, bool active_low, int flags,
> +                       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];
>         struct gpiod_line_request_config conf;
> @@ -259,7 +356,7 @@ int gpiod_ctxless_event_monitor_multiple(
>                 gpiod_line_bulk_add(&bulk, line);
>         }
>
> -       conf.flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
> +       conf.flags = ctxless_flags_to_line_request_flags(active_low, flags);
>         conf.consumer = consumer;
>
>         if (event_type == GPIOD_CTXLESS_EVENT_RISING_EDGE) {
> --
> 2.24.0
>
Kent Gibson Nov. 18, 2019, 2:12 p.m. UTC | #2
On Mon, Nov 18, 2019 at 02:51:06PM +0100, Bartosz Golaszewski wrote:
> pt., 15 lis 2019 o 15:44 Kent Gibson <warthog618@gmail.com> napisał(a):
> >
> > Extend the libgpiod API to support the bias flags recently added to the
> > kernel GPIO uAPI.  The core change is the addition of
> > GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE, GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP
> > and GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN flags to be passed into
> > line_request functions, and the addition of gpiod_line_bias to return the
> > bias state of lines.
> >
> > Extended variants of the ctxless functions that accept an active_low flag
> > are added to also accept other flags. The variant names add a "_ext"
> > suffix to the name of the original function.
> >
> > Based on initial work by Drew Fustini <drew@pdp7.com>.
> >
> > Signed-off-by: Kent Gibson <warthog618@gmail.com>
> 
> Hi Kent,
> 
> this looks good, just a couple nits. I'd change the subject line to
> "core: add support for bias flags". Also: how about moving the flags
> argument to the last position in all the ctxless extended variants, so
> that they keep the same signature *except* for the appended new
> argument?
> 

Will do.

Kent.

Patch
diff mbox series

diff --git a/include/gpiod.h b/include/gpiod.h
index 9860ea8..0f01cab 100644
--- a/include/gpiod.h
+++ b/include/gpiod.h
@@ -84,6 +84,22 @@  struct gpiod_line_bulk;
  * the need to use the gpiod_* structures or to keep track of resources.
  */
 
+/**
+ * @brief Miscellaneous GPIO flags.
+ */
+enum {
+	GPIOD_CTXLESS_FLAG_OPEN_DRAIN		= GPIOD_BIT(0),
+	/**< The line is an open-drain port. */
+	GPIOD_CTXLESS_FLAG_OPEN_SOURCE		= GPIOD_BIT(1),
+	/**< The line is an open-source port. */
+	GPIOD_CTXLESS_FLAG_BIAS_DISABLE		= GPIOD_BIT(2),
+	/**< The line has neither either pull-up nor pull-down resistor */
+	GPIOD_CTXLESS_FLAG_BIAS_PULL_DOWN	= GPIOD_BIT(3),
+	/**< The line has pull-down resistor enabled */
+	GPIOD_CTXLESS_FLAG_BIAS_PULL_UP		= GPIOD_BIT(4),
+	/**< The line has pull-up resistor enabled */
+};
+
 /**
  * @brief Read current value from a single GPIO line.
  * @param device Name, path, number or label of the gpiochip.
@@ -95,6 +111,19 @@  struct gpiod_line_bulk;
 int gpiod_ctxless_get_value(const char *device, unsigned int offset,
 			    bool active_low, const char *consumer) GPIOD_API;
 
+/**
+ * @brief Read current value from a single GPIO line.
+ * @param device Name, path, number or label of the gpiochip.
+ * @param offset Offset of the GPIO line.
+ * @param active_low The active state of this line - true if low.
+ * @param flags The flags for the line.
+ * @param consumer Name of the consumer.
+ * @return 0 or 1 (GPIO value) if the operation succeeds, -1 on error.
+ */
+int gpiod_ctxless_get_value_ext(const char *device, unsigned int offset,
+				bool active_low, int flags,
+				const char *consumer) GPIOD_API;
+
 /**
  * @brief Read current values from a set of GPIO lines.
  * @param device Name, path, number or label of the gpiochip.
@@ -110,6 +139,24 @@  int gpiod_ctxless_get_value_multiple(const char *device,
 				     unsigned int num_lines, bool active_low,
 				     const char *consumer) GPIOD_API;
 
+/**
+ * @brief Read current values from a set of GPIO lines.
+ * @param device Name, path, number or label of the gpiochip.
+ * @param offsets Array of offsets of lines whose values should be read.
+ * @param values Buffer in which the values will be stored.
+ * @param num_lines Number of lines, must be > 0.
+ * @param active_low The active state of this line - true if low.
+ * @param flags The flags for the lines.
+ * @param consumer Name of the consumer.
+ * @return 0 if the operation succeeds, -1 on error.
+ */
+int gpiod_ctxless_get_value_multiple_ext(const char *device,
+					 const unsigned int *offsets,
+					 int *values,
+					 unsigned int num_lines,
+					 bool active_low, int flags,
+					 const char *consumer) GPIOD_API;
+
 /**
  * @brief Simple set value callback signature.
  */
@@ -133,6 +180,26 @@  int gpiod_ctxless_set_value(const char *device, unsigned int offset, int value,
 			    gpiod_ctxless_set_value_cb cb,
 			    void *data) GPIOD_API;
 
+/**
+ * @brief Set value of a single GPIO line.
+ * @param device Name, path, number or label of the gpiochip.
+ * @param offset The offset of the GPIO line.
+ * @param value New value (0 or 1).
+ * @param active_low The active state of this line - true if low.
+ * @param flags The flags for the line.
+ * @param consumer Name of the consumer.
+ * @param cb Optional callback function that will be called right after setting
+ *           the value. Users can use this, for example, to pause the execution
+ *           after toggling a GPIO.
+ * @param data Optional user data that will be passed to the callback function.
+ * @return 0 if the operation succeeds, -1 on error.
+ */
+int gpiod_ctxless_set_value_ext(const char *device, unsigned int offset,
+				int value, bool active_low, int flags,
+				const char *consumer,
+				gpiod_ctxless_set_value_cb cb,
+				void *data) GPIOD_API;
+
 /**
  * @brief Set values of multiple GPIO lines.
  * @param device Name, path, number or label of the gpiochip.
@@ -153,6 +220,29 @@  int gpiod_ctxless_set_value_multiple(const char *device,
 				     gpiod_ctxless_set_value_cb cb,
 				     void *data) GPIOD_API;
 
+/**
+ * @brief Set values of multiple GPIO lines.
+ * @param device Name, path, number or label of the gpiochip.
+ * @param offsets Array of offsets of lines the values of which should be set.
+ * @param values Array of integers containing new values.
+ * @param num_lines Number of lines, must be > 0.
+ * @param active_low The active state of this line - true if low.
+ * @param flags The flags for the lines.
+ * @param consumer Name of the consumer.
+ * @param cb Optional callback function that will be called right after setting
+ *           all values. Works the same as in ::gpiod_ctxless_set_value.
+ * @param data Optional user data that will be passed to the callback function.
+ * @return 0 if the operation succeeds, -1 on error.
+ */
+int gpiod_ctxless_set_value_multiple_ext(const char *device,
+					 const unsigned int *offsets,
+					 const int *values,
+					 unsigned int num_lines,
+					 bool active_low, int flags,
+					 const char *consumer,
+					 gpiod_ctxless_set_value_cb cb,
+					 void *data) GPIOD_API;
+
 /**
  * @brief Event types that the ctxless event monitor can wait for.
  */
@@ -327,6 +417,31 @@  int gpiod_ctxless_event_monitor(const char *device, int event_type,
 				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 flags The flags for the line.
+ * @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_ext(const char *device, int event_type,
+				    unsigned int offset, bool active_low,
+				    int flags, 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.
@@ -366,6 +481,47 @@  int gpiod_ctxless_event_monitor_multiple(
 			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 flags The flags for the lines.
+ * @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 parameter 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_ext(
+			const char *device, int event_type,
+			const unsigned int *offsets,
+			unsigned int num_lines, bool active_low, int flags,
+			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.
@@ -658,6 +814,20 @@  enum {
 	/**< The active state of a GPIO is active-low. */
 };
 
+/**
+ * @brief Possible internal bias settings.
+ */
+enum {
+	GPIOD_LINE_BIAS_AS_IS = 1,
+	/**< The internal bias state is unknown. */
+	GPIOD_LINE_BIAS_DISABLE,
+	/**< The internal bias is disabled. */
+	GPIOD_LINE_BIAS_PULL_UP,
+	/**< The internal pull-up bias is enabled. */
+	GPIOD_LINE_BIAS_PULL_DOWN,
+	/**< The internal pull-down bias is enabled. */
+};
+
 /**
  * @brief Read the GPIO line offset.
  * @param line GPIO line object.
@@ -697,6 +867,14 @@  int gpiod_line_direction(struct gpiod_line *line) GPIOD_API;
  */
 int gpiod_line_active_state(struct gpiod_line *line) GPIOD_API;
 
+/**
+ * @brief Read the GPIO line bias setting.
+ * @param line GPIO line object.
+ * @return Returns GPIOD_LINE_BIAS_PULL_UP, GPIOD_LINE_BIAS_PULL_DOWN,
+ *         GPIOD_LINE_BIAS_DISABLE or GPIOD_LINE_BIAS_AS_IS.
+ */
+int gpiod_line_bias(struct gpiod_line *line) GPIOD_API;
+
 /**
  * @brief Check if the line is currently in use.
  * @param line GPIO line object.
@@ -792,6 +970,12 @@  enum {
 	/**< The line is an open-source port. */
 	GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW	= GPIOD_BIT(2),
 	/**< The active state of the line is low (high is the default). */
+	GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE	= GPIOD_BIT(3),
+	/**< The line has neither either pull-up nor pull-down resistor */
+	GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN	= GPIOD_BIT(4),
+	/**< The line has pull-down resistor enabled */
+	GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP	= GPIOD_BIT(5),
+	/**< The line has pull-up resistor enabled */
 };
 
 /**
diff --git a/lib/core.c b/lib/core.c
index f05e595..9b7d88f 100644
--- a/lib/core.c
+++ b/lib/core.c
@@ -36,9 +36,7 @@  struct gpiod_line {
 	unsigned int offset;
 	int direction;
 	int active_state;
-	bool used;
-	bool open_source;
-	bool open_drain;
+	__u32 flags;
 
 	int state;
 	bool needs_update;
@@ -359,19 +357,31 @@  int gpiod_line_active_state(struct gpiod_line *line)
 	return line->active_state;
 }
 
+int gpiod_line_bias(struct gpiod_line *line)
+{
+	if (line->flags & GPIOLINE_FLAG_BIAS_DISABLE)
+		return GPIOD_LINE_BIAS_DISABLE;
+	if (line->flags & GPIOLINE_FLAG_BIAS_PULL_UP)
+		return GPIOD_LINE_BIAS_PULL_UP;
+	if (line->flags & GPIOLINE_FLAG_BIAS_PULL_DOWN)
+		return GPIOD_LINE_BIAS_PULL_DOWN;
+
+	return GPIOD_LINE_BIAS_AS_IS;
+}
+
 bool gpiod_line_is_used(struct gpiod_line *line)
 {
-	return line->used;
+	return line->flags & GPIOLINE_FLAG_KERNEL;
 }
 
 bool gpiod_line_is_open_drain(struct gpiod_line *line)
 {
-	return line->open_drain;
+	return line->flags & GPIOLINE_FLAG_OPEN_DRAIN;
 }
 
 bool gpiod_line_is_open_source(struct gpiod_line *line)
 {
-	return line->open_source;
+	return line->flags & GPIOLINE_FLAG_OPEN_SOURCE;
 }
 
 bool gpiod_line_needs_update(struct gpiod_line *line)
@@ -398,9 +408,7 @@  int gpiod_line_update(struct gpiod_line *line)
 						? GPIOD_LINE_ACTIVE_STATE_LOW
 						: GPIOD_LINE_ACTIVE_STATE_HIGH;
 
-	line->used = info.flags & GPIOLINE_FLAG_KERNEL;
-	line->open_drain = info.flags & GPIOLINE_FLAG_OPEN_DRAIN;
-	line->open_source = info.flags & GPIOLINE_FLAG_OPEN_SOURCE;
+	line->flags = info.flags;
 
 	strncpy(line->name, info.name, sizeof(line->name));
 	strncpy(line->consumer, info.consumer, sizeof(line->consumer));
@@ -473,6 +481,12 @@  static __u32 line_request_flag_to_gpio_handleflag(int flags)
 		hflags |= GPIOHANDLE_REQUEST_OPEN_SOURCE;
 	if (flags & GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW)
 		hflags |= GPIOHANDLE_REQUEST_ACTIVE_LOW;
+	if (flags & GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE)
+		hflags |= GPIOHANDLE_REQUEST_BIAS_DISABLE;
+	if (flags & GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN)
+		hflags |= GPIOHANDLE_REQUEST_BIAS_PULL_DOWN;
+	if (flags & GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP)
+		hflags |= GPIOHANDLE_REQUEST_BIAS_PULL_UP;
 
 	return hflags;
 }
diff --git a/lib/ctxless.c b/lib/ctxless.c
index ba85018..44f1872 100644
--- a/lib/ctxless.c
+++ b/lib/ctxless.c
@@ -14,6 +14,26 @@ 
 #include <stdio.h>
 #include <string.h>
 
+static int ctxless_flags_to_line_request_flags(bool active_low, int flags)
+{
+	int lflags = 0;
+
+	if (active_low)
+		lflags |= GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW;
+	if (flags & GPIOD_CTXLESS_FLAG_OPEN_DRAIN)
+		lflags |= GPIOD_LINE_REQUEST_FLAG_OPEN_DRAIN;
+	if (flags & GPIOD_CTXLESS_FLAG_OPEN_SOURCE)
+		lflags |= GPIOD_LINE_REQUEST_FLAG_OPEN_SOURCE;
+	if (flags & GPIOD_CTXLESS_FLAG_BIAS_DISABLE)
+		lflags |= GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE;
+	if (flags & GPIOD_CTXLESS_FLAG_BIAS_PULL_UP)
+		lflags |= GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP;
+	if (flags & GPIOD_CTXLESS_FLAG_BIAS_PULL_DOWN)
+		lflags |= GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN;
+
+	return lflags;
+}
+
 int gpiod_ctxless_get_value(const char *device, unsigned int offset,
 			    bool active_low, const char *consumer)
 {
@@ -27,16 +47,45 @@  int gpiod_ctxless_get_value(const char *device, unsigned int offset,
 	return value;
 }
 
+int gpiod_ctxless_get_value_ext(const char *device, unsigned int offset,
+				bool active_low, int flags,
+				const char *consumer)
+{
+	int value, rv;
+
+	rv = gpiod_ctxless_get_value_multiple_ext(device, &offset, &value, 1,
+						  active_low, flags, consumer);
+	if (rv < 0)
+		return rv;
+
+	return value;
+}
+
 int gpiod_ctxless_get_value_multiple(const char *device,
 				     const unsigned int *offsets, int *values,
 				     unsigned int num_lines, bool active_low,
 				     const char *consumer)
+{
+	int rv;
+
+	rv = gpiod_ctxless_get_value_multiple_ext(device, offsets, values,
+						  num_lines, active_low, 0,
+						  consumer);
+	return rv;
+}
+
+int gpiod_ctxless_get_value_multiple_ext(const char *device,
+					 const unsigned int *offsets,
+					 int *values,
+					 unsigned int num_lines,
+					 bool active_low, int flags,
+					 const char *consumer)
 {
 	struct gpiod_line_bulk bulk;
 	struct gpiod_chip *chip;
 	struct gpiod_line *line;
 	unsigned int i;
-	int rv, flags;
+	int rv, lflags;
 
 	if (!num_lines || num_lines > GPIOD_LINE_BULK_MAX_LINES) {
 		errno = EINVAL;
@@ -59,9 +108,8 @@  int gpiod_ctxless_get_value_multiple(const char *device,
 		gpiod_line_bulk_add(&bulk, line);
 	}
 
-	flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
-
-	rv = gpiod_line_request_bulk_input_flags(&bulk, consumer, flags);
+	lflags = ctxless_flags_to_line_request_flags(active_low, flags);
+	rv = gpiod_line_request_bulk_input_flags(&bulk, consumer, lflags);
 	if (rv < 0) {
 		gpiod_chip_close(chip);
 		return -1;
@@ -83,17 +131,39 @@  int gpiod_ctxless_set_value(const char *device, unsigned int offset, int value,
 						active_low, consumer, cb, data);
 }
 
+int gpiod_ctxless_set_value_ext(const char *device, unsigned int offset,
+				int value, bool active_low, int flags,
+				const char *consumer,
+				gpiod_ctxless_set_value_cb cb, void *data)
+{
+	return gpiod_ctxless_set_value_multiple_ext(device, &offset, &value,
+						    1, active_low, flags,
+						    consumer, cb, data);
+}
+
 int gpiod_ctxless_set_value_multiple(const char *device,
 				     const unsigned int *offsets,
 				     const int *values, unsigned int num_lines,
 				     bool active_low, const char *consumer,
 				     gpiod_ctxless_set_value_cb cb, void *data)
+{
+	return gpiod_ctxless_set_value_multiple_ext(device, offsets, values,
+						    num_lines, active_low,
+						    0, consumer, cb, data);
+}
+
+int gpiod_ctxless_set_value_multiple_ext(
+			const char *device,
+			const unsigned int *offsets,
+			const int *values, unsigned int num_lines,
+			bool active_low, int flags, const char *consumer,
+			gpiod_ctxless_set_value_cb cb, void *data)
 {
 	struct gpiod_line_bulk bulk;
 	struct gpiod_chip *chip;
 	struct gpiod_line *line;
 	unsigned int i;
-	int rv, flags;
+	int rv, lflags;
 
 	if (!num_lines || num_lines > GPIOD_LINE_BULK_MAX_LINES) {
 		errno = EINVAL;
@@ -116,10 +186,9 @@  int gpiod_ctxless_set_value_multiple(const char *device,
 		gpiod_line_bulk_add(&bulk, line);
 	}
 
-	flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
-
+	lflags = ctxless_flags_to_line_request_flags(active_low, flags);
 	rv = gpiod_line_request_bulk_output_flags(&bulk, consumer,
-						  flags, values);
+						  lflags, values);
 	if (rv < 0) {
 		gpiod_chip_close(chip);
 		return -1;
@@ -216,6 +285,19 @@  int gpiod_ctxless_event_monitor(const char *device, int event_type,
 						    poll_cb, event_cb, data);
 }
 
+int gpiod_ctxless_event_monitor_ext(const char *device, int event_type,
+				    unsigned int offset, bool active_low,
+				    int flags, 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_ext(
+			device, event_type, &offset, 1, active_low,
+			flags, consumer, timeout, poll_cb, event_cb, data);
+}
+
 int gpiod_ctxless_event_monitor_multiple(
 			const char *device, int event_type,
 			const unsigned int *offsets,
@@ -225,6 +307,21 @@  int gpiod_ctxless_event_monitor_multiple(
 			gpiod_ctxless_event_poll_cb poll_cb,
 			gpiod_ctxless_event_handle_cb event_cb,
 			void *data)
+{
+	return gpiod_ctxless_event_monitor_multiple_ext(
+			device, event_type, offsets,
+			num_lines, active_low, 0, consumer, timeout,
+			poll_cb, event_cb, data);
+}
+
+int gpiod_ctxless_event_monitor_multiple_ext(
+			const char *device, int event_type,
+			const unsigned int *offsets,
+			unsigned int num_lines, bool active_low, int flags,
+			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];
 	struct gpiod_line_request_config conf;
@@ -259,7 +356,7 @@  int gpiod_ctxless_event_monitor_multiple(
 		gpiod_line_bulk_add(&bulk, line);
 	}
 
-	conf.flags = active_low ? GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW : 0;
+	conf.flags = ctxless_flags_to_line_request_flags(active_low, flags);
 	conf.consumer = consumer;
 
 	if (event_type == GPIOD_CTXLESS_EVENT_RISING_EDGE) {