gpiod.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * This file is part of libgpiod.
 *
 * Copyright (C) 2017-2018 Bartosz Golaszewski <bartekgola@gmail.com>
 */
 
#ifndef __LIBGPIOD_GPIOD_H__
#define __LIBGPIOD_GPIOD_H__
 
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct gpiod_chip;
struct gpiod_line;
struct gpiod_chip_iter;
struct gpiod_line_iter;
struct gpiod_line_bulk;
 
#define GPIOD_API               __attribute__((visibility("default")))
 
#define GPIOD_UNUSED            __attribute__((unused))
 
#define GPIOD_BIT(nr)           (1UL << (nr))
 
#define GPIOD_DEPRECATED        __attribute__((deprecated))
 
enum {
        GPIOD_CTXLESS_FLAG_OPEN_DRAIN           = GPIOD_BIT(0),
        GPIOD_CTXLESS_FLAG_OPEN_SOURCE          = GPIOD_BIT(1),
        GPIOD_CTXLESS_FLAG_BIAS_DISABLE         = GPIOD_BIT(2),
        GPIOD_CTXLESS_FLAG_BIAS_PULL_DOWN       = GPIOD_BIT(3),
        GPIOD_CTXLESS_FLAG_BIAS_PULL_UP         = GPIOD_BIT(4),
};
 
int gpiod_ctxless_get_value(const char *device, unsigned int offset,
                            bool active_low, const char *consumer) GPIOD_API;
 
int gpiod_ctxless_get_value_ext(const char *device, unsigned int offset,
                                bool active_low, const char *consumer,
                                int flags) GPIOD_API;
 
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) GPIOD_API;
 
int gpiod_ctxless_get_value_multiple_ext(const char *device,
                                         const unsigned int *offsets,
                                         int *values, unsigned int num_lines,
                                         bool active_low, const char *consumer,
                                         int flags) GPIOD_API;
 
typedef void (*gpiod_ctxless_set_value_cb)(void *);
 
int gpiod_ctxless_set_value(const char *device, unsigned int offset, int value,
                            bool active_low, const char *consumer,
                            gpiod_ctxless_set_value_cb cb,
                            void *data) GPIOD_API;
 
int gpiod_ctxless_set_value_ext(const char *device, unsigned int offset,
                                int value, bool active_low,
                                const char *consumer,
                                gpiod_ctxless_set_value_cb cb,
                                void *data, int flags) GPIOD_API;
 
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) GPIOD_API;
 
int gpiod_ctxless_set_value_multiple_ext(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, int flags) GPIOD_API;
 
enum {
        GPIOD_CTXLESS_EVENT_RISING_EDGE = 1,
        GPIOD_CTXLESS_EVENT_FALLING_EDGE,
        GPIOD_CTXLESS_EVENT_BOTH_EDGES,
};
 
enum {
        GPIOD_CTXLESS_EVENT_CB_TIMEOUT = 1,
        GPIOD_CTXLESS_EVENT_CB_RISING_EDGE,
        GPIOD_CTXLESS_EVENT_CB_FALLING_EDGE,
};
 
enum {
        GPIOD_CTXLESS_EVENT_CB_RET_ERR = -1,
        GPIOD_CTXLESS_EVENT_CB_RET_OK = 0,
        GPIOD_CTXLESS_EVENT_CB_RET_STOP = 1,
};
 
typedef int (*gpiod_ctxless_event_handle_cb)(int, unsigned int,
                                             const struct timespec *, void *);
 
enum {
        GPIOD_CTXLESS_EVENT_POLL_RET_STOP = -2,
        GPIOD_CTXLESS_EVENT_POLL_RET_ERR = -1,
        GPIOD_CTXLESS_EVENT_POLL_RET_TIMEOUT = 0,
};
 
struct gpiod_ctxless_event_poll_fd {
        int fd;
        bool event;
};
 
typedef int (*gpiod_ctxless_event_poll_cb)(unsigned int,
                                struct gpiod_ctxless_event_poll_fd *,
                                const struct timespec *, void *);
 
int gpiod_ctxless_event_loop(const char *device, 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 GPIOD_DEPRECATED;
 
int gpiod_ctxless_event_loop_multiple(const char *device,
                                      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 GPIOD_DEPRECATED;
 
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;
 
int gpiod_ctxless_event_monitor_ext(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, int flags) GPIOD_API;
 
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;
 
int gpiod_ctxless_event_monitor_multiple_ext(
                        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, int flags) GPIOD_API;
 
 
int gpiod_ctxless_find_line(const char *name, char *chipname,
                            size_t chipname_size,
                            unsigned int *offset) GPIOD_API;
 
struct gpiod_chip *gpiod_chip_open(const char *path) GPIOD_API;
 
struct gpiod_chip *gpiod_chip_open_by_name(const char *name) GPIOD_API;
 
struct gpiod_chip *gpiod_chip_open_by_number(unsigned int num) GPIOD_API;
 
struct gpiod_chip *gpiod_chip_open_by_label(const char *label) GPIOD_API;
 
struct gpiod_chip *gpiod_chip_open_lookup(const char *descr) GPIOD_API;
 
void gpiod_chip_close(struct gpiod_chip *chip) GPIOD_API;
 
const char *gpiod_chip_name(struct gpiod_chip *chip) GPIOD_API;
 
const char *gpiod_chip_label(struct gpiod_chip *chip) GPIOD_API;
 
unsigned int gpiod_chip_num_lines(struct gpiod_chip *chip) GPIOD_API;
 
struct gpiod_line *
gpiod_chip_get_line(struct gpiod_chip *chip, unsigned int offset) GPIOD_API;
 
int gpiod_chip_get_lines(struct gpiod_chip *chip,
                         unsigned int *offsets, unsigned int num_offsets,
                         struct gpiod_line_bulk *bulk) GPIOD_API;
 
int gpiod_chip_get_all_lines(struct gpiod_chip *chip,
                             struct gpiod_line_bulk *bulk) GPIOD_API;
 
struct gpiod_line *
gpiod_chip_find_line(struct gpiod_chip *chip, const char *name) GPIOD_API;
 
int gpiod_chip_find_lines(struct gpiod_chip *chip, const char **names,
                          struct gpiod_line_bulk *bulk) GPIOD_API;
 
#define GPIOD_LINE_BULK_MAX_LINES       64
 
struct gpiod_line_bulk {
        struct gpiod_line *lines[GPIOD_LINE_BULK_MAX_LINES];
        unsigned int num_lines;
};
 
#define GPIOD_LINE_BULK_INITIALIZER     { { NULL }, 0 }
 
static inline void gpiod_line_bulk_init(struct gpiod_line_bulk *bulk)
{
        bulk->num_lines = 0;
}
 
static inline void gpiod_line_bulk_add(struct gpiod_line_bulk *bulk,
                                       struct gpiod_line *line)
{
        bulk->lines[bulk->num_lines++] = line;
}
 
static inline struct gpiod_line *
gpiod_line_bulk_get_line(struct gpiod_line_bulk *bulk, unsigned int offset)
{
        return bulk->lines[offset];
}
 
static inline unsigned int
gpiod_line_bulk_num_lines(struct gpiod_line_bulk *bulk)
{
        return bulk->num_lines;
}
 
#define gpiod_line_bulk_foreach_line(bulk, line, lineptr)               \
        for ((lineptr) = (bulk)->lines, (line) = *(lineptr);            \
             (lineptr) <= (bulk)->lines + ((bulk)->num_lines - 1);      \
             (lineptr)++, (line) = *(lineptr))
 
#define gpiod_line_bulk_foreach_line_off(bulk, line, offset)            \
        for ((offset) = 0, (line) = (bulk)->lines[0];                   \
             (offset) < (bulk)->num_lines;                              \
             (offset)++, (line) = (bulk)->lines[(offset)])
 
enum {
        GPIOD_LINE_DIRECTION_INPUT = 1,
        GPIOD_LINE_DIRECTION_OUTPUT,
};
 
enum {
        GPIOD_LINE_ACTIVE_STATE_HIGH = 1,
        GPIOD_LINE_ACTIVE_STATE_LOW,
};
 
enum {
        GPIOD_LINE_BIAS_AS_IS = 1,
        GPIOD_LINE_BIAS_DISABLE,
        GPIOD_LINE_BIAS_PULL_UP,
        GPIOD_LINE_BIAS_PULL_DOWN,
};
 
unsigned int gpiod_line_offset(struct gpiod_line *line) GPIOD_API;
 
const char *gpiod_line_name(struct gpiod_line *line) GPIOD_API;
 
const char *gpiod_line_consumer(struct gpiod_line *line) GPIOD_API;
 
int gpiod_line_direction(struct gpiod_line *line) GPIOD_API;
 
int gpiod_line_active_state(struct gpiod_line *line) GPIOD_API;
 
int gpiod_line_bias(struct gpiod_line *line) GPIOD_API;
 
bool gpiod_line_is_used(struct gpiod_line *line) GPIOD_API;
 
bool gpiod_line_is_open_drain(struct gpiod_line *line) GPIOD_API;
 
bool gpiod_line_is_open_source(struct gpiod_line *line) GPIOD_API;
 
int gpiod_line_update(struct gpiod_line *line) GPIOD_API;
 
bool
gpiod_line_needs_update(struct gpiod_line *line) GPIOD_API GPIOD_DEPRECATED;
 
enum {
        GPIOD_LINE_REQUEST_DIRECTION_AS_IS = 1,
        GPIOD_LINE_REQUEST_DIRECTION_INPUT,
        GPIOD_LINE_REQUEST_DIRECTION_OUTPUT,
        GPIOD_LINE_REQUEST_EVENT_FALLING_EDGE,
        GPIOD_LINE_REQUEST_EVENT_RISING_EDGE,
        GPIOD_LINE_REQUEST_EVENT_BOTH_EDGES,
};
 
enum {
        GPIOD_LINE_REQUEST_FLAG_OPEN_DRAIN      = GPIOD_BIT(0),
        GPIOD_LINE_REQUEST_FLAG_OPEN_SOURCE     = GPIOD_BIT(1),
        GPIOD_LINE_REQUEST_FLAG_ACTIVE_LOW      = GPIOD_BIT(2),
        GPIOD_LINE_REQUEST_FLAG_BIAS_DISABLE    = GPIOD_BIT(3),
        GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_DOWN  = GPIOD_BIT(4),
        GPIOD_LINE_REQUEST_FLAG_BIAS_PULL_UP    = GPIOD_BIT(5),
};
 
struct gpiod_line_request_config {
        const char *consumer;
        int request_type;
        int flags;
};
 
int gpiod_line_request(struct gpiod_line *line,
                       const struct gpiod_line_request_config *config,
                       int default_val) GPIOD_API;
 
int gpiod_line_request_input(struct gpiod_line *line,
                             const char *consumer) GPIOD_API;
 
int gpiod_line_request_output(struct gpiod_line *line,
                              const char *consumer, int default_val) GPIOD_API;
 
int gpiod_line_request_rising_edge_events(struct gpiod_line *line,
                                          const char *consumer) GPIOD_API;
 
int gpiod_line_request_falling_edge_events(struct gpiod_line *line,
                                           const char *consumer) GPIOD_API;
 
int gpiod_line_request_both_edges_events(struct gpiod_line *line,
                                         const char *consumer) GPIOD_API;
 
int gpiod_line_request_input_flags(struct gpiod_line *line,
                                   const char *consumer, int flags) GPIOD_API;
 
int gpiod_line_request_output_flags(struct gpiod_line *line,
                                    const char *consumer, int flags,
                                    int default_val) GPIOD_API;
 
int gpiod_line_request_rising_edge_events_flags(struct gpiod_line *line,
                                                const char *consumer,
                                                int flags) GPIOD_API;
 
int gpiod_line_request_falling_edge_events_flags(struct gpiod_line *line,
                                                 const char *consumer,
                                                 int flags) GPIOD_API;
 
int gpiod_line_request_both_edges_events_flags(struct gpiod_line *line,
                                               const char *consumer,
                                               int flags) GPIOD_API;
 
int gpiod_line_request_bulk(struct gpiod_line_bulk *bulk,
                            const struct gpiod_line_request_config *config,
                            const int *default_vals) GPIOD_API;
 
int gpiod_line_request_bulk_input(struct gpiod_line_bulk *bulk,
                                  const char *consumer) GPIOD_API;
 
int gpiod_line_request_bulk_output(struct gpiod_line_bulk *bulk,
                                   const char *consumer,
                                   const int *default_vals) GPIOD_API;
 
int gpiod_line_request_bulk_rising_edge_events(struct gpiod_line_bulk *bulk,
                                               const char *consumer) GPIOD_API;
 
int gpiod_line_request_bulk_falling_edge_events(struct gpiod_line_bulk *bulk,
                                                const char *consumer) GPIOD_API;
 
int gpiod_line_request_bulk_both_edges_events(struct gpiod_line_bulk *bulk,
                                              const char *consumer) GPIOD_API;
 
int gpiod_line_request_bulk_input_flags(struct gpiod_line_bulk *bulk,
                                        const char *consumer,
                                        int flags) GPIOD_API;
 
int gpiod_line_request_bulk_output_flags(struct gpiod_line_bulk *bulk,
                                         const char *consumer, int flags,
                                         const int *default_vals) GPIOD_API;
 
int gpiod_line_request_bulk_rising_edge_events_flags(
                                        struct gpiod_line_bulk *bulk,
                                        const char *consumer,
                                        int flags) GPIOD_API;
 
int gpiod_line_request_bulk_falling_edge_events_flags(
                                        struct gpiod_line_bulk *bulk,
                                        const char *consumer,
                                        int flags) GPIOD_API;
 
int gpiod_line_request_bulk_both_edges_events_flags(
                                        struct gpiod_line_bulk *bulk,
                                        const char *consumer,
                                        int flags) GPIOD_API;
 
void gpiod_line_release(struct gpiod_line *line) GPIOD_API;
 
void gpiod_line_release_bulk(struct gpiod_line_bulk *bulk) GPIOD_API;
 
bool gpiod_line_is_requested(struct gpiod_line *line) GPIOD_API;
 
bool gpiod_line_is_free(struct gpiod_line *line) GPIOD_API;
 
int gpiod_line_get_value(struct gpiod_line *line) GPIOD_API;
 
int gpiod_line_get_value_bulk(struct gpiod_line_bulk *bulk,
                              int *values) GPIOD_API;
 
int gpiod_line_set_value(struct gpiod_line *line, int value) GPIOD_API;
 
int gpiod_line_set_value_bulk(struct gpiod_line_bulk *bulk,
                              const int *values) GPIOD_API;
 
int gpiod_line_set_config(struct gpiod_line *line, int direction,
                          int flags, int value) GPIOD_API;
 
int gpiod_line_set_config_bulk(struct gpiod_line_bulk *bulk,
                               int direction, int flags,
                               const int *values) GPIOD_API;
 
 
int gpiod_line_set_flags(struct gpiod_line *line, int flags) GPIOD_API;
 
int gpiod_line_set_flags_bulk(struct gpiod_line_bulk *bulk,
                              int flags) GPIOD_API;
 
int gpiod_line_set_direction_input(struct gpiod_line *line) GPIOD_API;
 
int
gpiod_line_set_direction_input_bulk(struct gpiod_line_bulk *bulk) GPIOD_API;
 
int gpiod_line_set_direction_output(struct gpiod_line *line,
                                    int value) GPIOD_API;
 
int gpiod_line_set_direction_output_bulk(struct gpiod_line_bulk *bulk,
                                         const int *values) GPIOD_API;
 
enum {
        GPIOD_LINE_EVENT_RISING_EDGE = 1,
        GPIOD_LINE_EVENT_FALLING_EDGE,
};
 
struct gpiod_line_event {
        struct timespec ts;
        int event_type;
};
 
int gpiod_line_event_wait(struct gpiod_line *line,
                          const struct timespec *timeout) GPIOD_API;
 
int gpiod_line_event_wait_bulk(struct gpiod_line_bulk *bulk,
                               const struct timespec *timeout,
                               struct gpiod_line_bulk *event_bulk) GPIOD_API;
 
int gpiod_line_event_read(struct gpiod_line *line,
                          struct gpiod_line_event *event) GPIOD_API;
 
int gpiod_line_event_read_multiple(struct gpiod_line *line,
                                   struct gpiod_line_event *events,
                                   unsigned int num_events) GPIOD_API;
 
int gpiod_line_event_get_fd(struct gpiod_line *line) GPIOD_API;
 
int gpiod_line_event_read_fd(int fd, struct gpiod_line_event *event) GPIOD_API;
 
int gpiod_line_event_read_fd_multiple(int fd, struct gpiod_line_event *events,
                                      unsigned int num_events) GPIOD_API;
 
struct gpiod_line *
gpiod_line_get(const char *device, unsigned int offset) GPIOD_API;
 
struct gpiod_line *gpiod_line_find(const char *name) GPIOD_API;
 
void gpiod_line_close_chip(struct gpiod_line *line) GPIOD_API;
 
struct gpiod_chip *gpiod_line_get_chip(struct gpiod_line *line) GPIOD_API;
 
struct gpiod_chip_iter *gpiod_chip_iter_new(void) GPIOD_API;
 
void gpiod_chip_iter_free(struct gpiod_chip_iter *iter) GPIOD_API;
 
void gpiod_chip_iter_free_noclose(struct gpiod_chip_iter *iter) GPIOD_API;
 
struct gpiod_chip *
gpiod_chip_iter_next(struct gpiod_chip_iter *iter) GPIOD_API;
 
struct gpiod_chip *
gpiod_chip_iter_next_noclose(struct gpiod_chip_iter *iter) GPIOD_API;
 
#define gpiod_foreach_chip(iter, chip)                                  \
        for ((chip) = gpiod_chip_iter_next(iter);                       \
             (chip);                                                    \
             (chip) = gpiod_chip_iter_next(iter))
 
#define gpiod_foreach_chip_noclose(iter, chip)                          \
        for ((chip) = gpiod_chip_iter_next_noclose(iter);               \
             (chip);                                                    \
             (chip) = gpiod_chip_iter_next_noclose(iter))
 
struct gpiod_line_iter *
gpiod_line_iter_new(struct gpiod_chip *chip) GPIOD_API;
 
void gpiod_line_iter_free(struct gpiod_line_iter *iter) GPIOD_API;
 
struct gpiod_line *
gpiod_line_iter_next(struct gpiod_line_iter *iter) GPIOD_API;
 
#define gpiod_foreach_line(iter, line)                                  \
        for ((line) = gpiod_line_iter_next(iter);                       \
             (line);                                                    \
             (line) = gpiod_line_iter_next(iter))
 
const char *gpiod_version_string(void) GPIOD_API;
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* __LIBGPIOD_GPIOD_H__ */