gpiod.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/* SPDX-FileCopyrightText: 2017-2022 Bartosz Golaszewski <brgl@bgdev.pl> */
 
#ifndef __LIBGPIOD_GPIOD_H__
#define __LIBGPIOD_GPIOD_H__
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct gpiod_chip;
 
struct gpiod_chip_info;
 
struct gpiod_line_info;
 
struct gpiod_line_settings;
 
struct gpiod_line_config;
 
struct gpiod_request_config;
 
struct gpiod_line_request;
 
struct gpiod_info_event;
 
struct gpiod_edge_event;
 
struct gpiod_edge_event_buffer;
 
struct gpiod_chip *gpiod_chip_open(const char *path);
 
void gpiod_chip_close(struct gpiod_chip *chip);
 
struct gpiod_chip_info *gpiod_chip_get_info(struct gpiod_chip *chip);
 
const char *gpiod_chip_get_path(struct gpiod_chip *chip);
 
struct gpiod_line_info *gpiod_chip_get_line_info(struct gpiod_chip *chip,
                                                 unsigned int offset);
 
struct gpiod_line_info *gpiod_chip_watch_line_info(struct gpiod_chip *chip,
                                                   unsigned int offset);
 
int gpiod_chip_unwatch_line_info(struct gpiod_chip *chip, unsigned int offset);
 
int gpiod_chip_get_fd(struct gpiod_chip *chip);
 
int gpiod_chip_wait_info_event(struct gpiod_chip *chip, int64_t timeout_ns);
 
struct gpiod_info_event *gpiod_chip_read_info_event(struct gpiod_chip *chip);
 
int gpiod_chip_get_line_offset_from_name(struct gpiod_chip *chip,
                                         const char *name);
 
struct gpiod_line_request *
gpiod_chip_request_lines(struct gpiod_chip *chip,
                         struct gpiod_request_config *req_cfg,
                         struct gpiod_line_config *line_cfg);
 
void gpiod_chip_info_free(struct gpiod_chip_info *info);
 
const char *gpiod_chip_info_get_name(struct gpiod_chip_info *info);
 
const char *gpiod_chip_info_get_label(struct gpiod_chip_info *info);
 
size_t gpiod_chip_info_get_num_lines(struct gpiod_chip_info *info);
 
enum gpiod_line_value {
        GPIOD_LINE_VALUE_ERROR = -1,
        GPIOD_LINE_VALUE_INACTIVE = 0,
        GPIOD_LINE_VALUE_ACTIVE = 1,
};
 
enum gpiod_line_direction {
        GPIOD_LINE_DIRECTION_AS_IS = 1,
        GPIOD_LINE_DIRECTION_INPUT,
        GPIOD_LINE_DIRECTION_OUTPUT,
};
 
enum gpiod_line_edge {
        GPIOD_LINE_EDGE_NONE = 1,
        GPIOD_LINE_EDGE_RISING,
        GPIOD_LINE_EDGE_FALLING,
        GPIOD_LINE_EDGE_BOTH,
};
 
enum gpiod_line_bias {
        GPIOD_LINE_BIAS_AS_IS = 1,
        GPIOD_LINE_BIAS_UNKNOWN,
        GPIOD_LINE_BIAS_DISABLED,
        GPIOD_LINE_BIAS_PULL_UP,
        GPIOD_LINE_BIAS_PULL_DOWN,
};
 
enum gpiod_line_drive {
        GPIOD_LINE_DRIVE_PUSH_PULL = 1,
        GPIOD_LINE_DRIVE_OPEN_DRAIN,
        GPIOD_LINE_DRIVE_OPEN_SOURCE,
};
 
enum gpiod_line_clock {
        GPIOD_LINE_CLOCK_MONOTONIC = 1,
        GPIOD_LINE_CLOCK_REALTIME,
        GPIOD_LINE_CLOCK_HTE,
};
 
void gpiod_line_info_free(struct gpiod_line_info *info);
 
struct gpiod_line_info *gpiod_line_info_copy(struct gpiod_line_info *info);
 
unsigned int gpiod_line_info_get_offset(struct gpiod_line_info *info);
 
const char *gpiod_line_info_get_name(struct gpiod_line_info *info);
 
bool gpiod_line_info_is_used(struct gpiod_line_info *info);
 
const char *gpiod_line_info_get_consumer(struct gpiod_line_info *info);
 
enum gpiod_line_direction
gpiod_line_info_get_direction(struct gpiod_line_info *info);
 
enum gpiod_line_edge
gpiod_line_info_get_edge_detection(struct gpiod_line_info *info);
 
enum gpiod_line_bias
gpiod_line_info_get_bias(struct gpiod_line_info *info);
 
enum gpiod_line_drive
gpiod_line_info_get_drive(struct gpiod_line_info *info);
 
bool gpiod_line_info_is_active_low(struct gpiod_line_info *info);
 
bool gpiod_line_info_is_debounced(struct gpiod_line_info *info);
 
unsigned long
gpiod_line_info_get_debounce_period_us(struct gpiod_line_info *info);
 
enum gpiod_line_clock
gpiod_line_info_get_event_clock(struct gpiod_line_info *info);
 
enum gpiod_info_event_type {
        GPIOD_INFO_EVENT_LINE_REQUESTED = 1,
        GPIOD_INFO_EVENT_LINE_RELEASED,
        GPIOD_INFO_EVENT_LINE_CONFIG_CHANGED,
};
 
void gpiod_info_event_free(struct gpiod_info_event *event);
 
enum gpiod_info_event_type
gpiod_info_event_get_event_type(struct gpiod_info_event *event);
 
uint64_t gpiod_info_event_get_timestamp_ns(struct gpiod_info_event *event);
 
struct gpiod_line_info *
gpiod_info_event_get_line_info(struct gpiod_info_event *event);
 
struct gpiod_line_settings *gpiod_line_settings_new(void);
 
void gpiod_line_settings_free(struct gpiod_line_settings *settings);
 
void gpiod_line_settings_reset(struct gpiod_line_settings *settings);
 
struct gpiod_line_settings *
gpiod_line_settings_copy(struct gpiod_line_settings *settings);
 
int gpiod_line_settings_set_direction(struct gpiod_line_settings *settings,
                                      enum gpiod_line_direction direction);
 
enum gpiod_line_direction
gpiod_line_settings_get_direction(struct gpiod_line_settings *settings);
 
int gpiod_line_settings_set_edge_detection(struct gpiod_line_settings *settings,
                                           enum gpiod_line_edge edge);
 
enum gpiod_line_edge
gpiod_line_settings_get_edge_detection(struct gpiod_line_settings *settings);
 
int gpiod_line_settings_set_bias(struct gpiod_line_settings *settings,
                                 enum gpiod_line_bias bias);
 
enum gpiod_line_bias
gpiod_line_settings_get_bias(struct gpiod_line_settings *settings);
 
int gpiod_line_settings_set_drive(struct gpiod_line_settings *settings,
                                  enum gpiod_line_drive drive);
 
enum gpiod_line_drive
gpiod_line_settings_get_drive(struct gpiod_line_settings *settings);
 
void gpiod_line_settings_set_active_low(struct gpiod_line_settings *settings,
                                        bool active_low);
 
bool gpiod_line_settings_get_active_low(struct gpiod_line_settings *settings);
 
void
gpiod_line_settings_set_debounce_period_us(struct gpiod_line_settings *settings,
                                           unsigned long period);
 
unsigned long
gpiod_line_settings_get_debounce_period_us(
                struct gpiod_line_settings *settings);
 
int gpiod_line_settings_set_event_clock(struct gpiod_line_settings *settings,
                                enum gpiod_line_clock event_clock);
 
enum gpiod_line_clock
gpiod_line_settings_get_event_clock(struct gpiod_line_settings *settings);
 
int gpiod_line_settings_set_output_value(struct gpiod_line_settings *settings,
                                         enum gpiod_line_value value);
 
enum gpiod_line_value
gpiod_line_settings_get_output_value(struct gpiod_line_settings *settings);
 
struct gpiod_line_config *gpiod_line_config_new(void);
 
void gpiod_line_config_free(struct gpiod_line_config *config);
 
void gpiod_line_config_reset(struct gpiod_line_config *config);
 
int gpiod_line_config_add_line_settings(struct gpiod_line_config *config,
                                        const unsigned int *offsets,
                                        size_t num_offsets,
                                        struct gpiod_line_settings *settings);
 
struct gpiod_line_settings *
gpiod_line_config_get_line_settings(struct gpiod_line_config *config,
                                    unsigned int offset);
 
int gpiod_line_config_set_output_values(struct gpiod_line_config *config,
                                        const enum gpiod_line_value *values,
                                        size_t num_values);
 
size_t
gpiod_line_config_get_num_configured_offsets(struct gpiod_line_config *config);
 
size_t
gpiod_line_config_get_configured_offsets(struct gpiod_line_config *config,
                                         unsigned int *offsets,
                                         size_t max_offsets);
 
struct gpiod_request_config *gpiod_request_config_new(void);
 
void gpiod_request_config_free(struct gpiod_request_config *config);
 
void gpiod_request_config_set_consumer(struct gpiod_request_config *config,
                                       const char *consumer);
 
const char *
gpiod_request_config_get_consumer(struct gpiod_request_config *config);
 
void
gpiod_request_config_set_event_buffer_size(struct gpiod_request_config *config,
                                           size_t event_buffer_size);
 
size_t
gpiod_request_config_get_event_buffer_size(struct gpiod_request_config *config);
 
void gpiod_line_request_release(struct gpiod_line_request *request);
 
size_t
gpiod_line_request_get_num_requested_lines(struct gpiod_line_request *request);
 
size_t
gpiod_line_request_get_requested_offsets(struct gpiod_line_request *request,
                                         unsigned int *offsets,
                                         size_t max_offsets);
 
enum gpiod_line_value
gpiod_line_request_get_value(struct gpiod_line_request *request,
                             unsigned int offset);
 
int gpiod_line_request_get_values_subset(struct gpiod_line_request *request,
                                         size_t num_values,
                                         const unsigned int *offsets,
                                         enum gpiod_line_value *values);
 
int gpiod_line_request_get_values(struct gpiod_line_request *request,
                                  enum gpiod_line_value *values);
 
int gpiod_line_request_set_value(struct gpiod_line_request *request,
                                 unsigned int offset,
                                 enum gpiod_line_value value);
 
int gpiod_line_request_set_values_subset(struct gpiod_line_request *request,
                                         size_t num_values,
                                         const unsigned int *offsets,
                                         const enum gpiod_line_value *values);
 
int gpiod_line_request_set_values(struct gpiod_line_request *request,
                                  const enum gpiod_line_value *values);
 
int gpiod_line_request_reconfigure_lines(struct gpiod_line_request *request,
                                         struct gpiod_line_config *config);
 
int gpiod_line_request_get_fd(struct gpiod_line_request *request);
 
int gpiod_line_request_wait_edge_events(struct gpiod_line_request *request,
                                        int64_t timeout_ns);
 
int gpiod_line_request_read_edge_events(struct gpiod_line_request *request,
                                        struct gpiod_edge_event_buffer *buffer,
                                        size_t max_events);
 
enum gpiod_edge_event_type {
        GPIOD_EDGE_EVENT_RISING_EDGE = 1,
        GPIOD_EDGE_EVENT_FALLING_EDGE,
};
 
void gpiod_edge_event_free(struct gpiod_edge_event *event);
 
struct gpiod_edge_event *gpiod_edge_event_copy(struct gpiod_edge_event *event);
 
enum gpiod_edge_event_type
gpiod_edge_event_get_event_type(struct gpiod_edge_event *event);
 
uint64_t gpiod_edge_event_get_timestamp_ns(struct gpiod_edge_event *event);
 
unsigned int gpiod_edge_event_get_line_offset(struct gpiod_edge_event *event);
 
unsigned long gpiod_edge_event_get_global_seqno(struct gpiod_edge_event *event);
 
unsigned long gpiod_edge_event_get_line_seqno(struct gpiod_edge_event *event);
 
struct gpiod_edge_event_buffer *
gpiod_edge_event_buffer_new(size_t capacity);
 
size_t
gpiod_edge_event_buffer_get_capacity(struct gpiod_edge_event_buffer *buffer);
 
void gpiod_edge_event_buffer_free(struct gpiod_edge_event_buffer *buffer);
 
struct gpiod_edge_event *
gpiod_edge_event_buffer_get_event(struct gpiod_edge_event_buffer *buffer,
                                  unsigned long index);
 
size_t
gpiod_edge_event_buffer_get_num_events(struct gpiod_edge_event_buffer *buffer);
 
bool gpiod_is_gpiochip_device(const char *path);
 
const char *gpiod_api_version(void);
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* __LIBGPIOD_GPIOD_H__ */