LibXR::LinuxGPIO Class Reference

基于 Linux GPIO character device uAPI 的 Linux GPIO 实现 Linux GPIO implementation based on the Linux GPIO character-device uAPI More...

#include <linux_gpio.hpp>

Inheritance diagram for LibXR::LinuxGPIO:

Collaboration diagram for LibXR::LinuxGPIO:

Public Member Functions
	LinuxGPIO (const std::string &chip_path, unsigned int line_offset)
	LinuxGPIO (const LinuxGPIO &)=delete
LinuxGPIO &	operator= (const LinuxGPIO &)=delete
bool	Read () override
	读取 GPIO 引脚状态。Reads the GPIO pin state.
void	Write (bool value) override
	写入 GPIO 引脚状态。Writes the GPIO pin state.
ErrorCode	EnableInterrupt () override
	使能 GPIO 引脚中断。Enables the GPIO pin interrupt.
ErrorCode	DisableInterrupt () override
	禁用 GPIO 引脚中断。Disables the GPIO pin interrupt.
ErrorCode	SetConfig (Configuration config) override
	配置 GPIO 引脚参数。Configures the GPIO pin settings.
Public Member Functions inherited from LibXR::GPIO
	GPIO ()
	默认构造函数。Default constructor.
virtual	~GPIO ()=default
	虚析构函数。Virtual destructor.
ErrorCode	RegisterCallback (Callback callback)
	注册 GPIO 事件回调函数。Registers a callback function for GPIO events.

Private Types
enum class	AbiVersion : uint8_t { UNKNOWN = 0 , V2 = 1 , V1 = 2 }
enum class	RequestKind : uint8_t { NONE = 0 , HANDLE = 1 , EVENT = 2 }

Private Member Functions
ErrorCode	OpenChip ()
void	CloseChip ()
void	CloseRequest ()
ErrorCode	InitInterruptWakePipe ()
void	CloseInterruptWakePipe ()
void	NotifyInterruptThread ()
void	WaitForInterruptLoopIdle ()
void	WaitForInterruptThreadStopped ()
ErrorCode	DetectAbiVersion ()
ErrorCode	ReopenRequest (Configuration config)
ErrorCode	OpenRequestV2 (Configuration config)
ErrorCode	ReconfigureRequestV2 (Configuration config)
ErrorCode	OpenRequestV1 (Configuration config)
ErrorCode	ReconfigureRequestV1 (Configuration config)
ErrorCode	PumpEventQueue (int fd, AbiVersion abi_version, size_t &event_count, int timeout_ms) const
ErrorCode	ReadEventsV2 (int fd, size_t &event_count) const
ErrorCode	ReadEventsV1 (int fd, size_t &event_count) const
void	StartInterruptThread ()
void	InterruptLoop ()
ErrorCode	EnsureConfigured () const
bool	NeedsRequestReopen (Configuration config) const

Static Private Member Functions
static bool	IsInterruptDirection (Direction direction)

Private Attributes
std::string	chip_path_
unsigned int	line_offset_ = 0U
int	chip_fd_ = -1
std::atomic< int >	request_fd_ {-1}
std::atomic< AbiVersion >	abi_version_ {AbiVersion::UNKNOWN}
std::atomic< RequestKind >	request_kind_ {RequestKind::NONE}
Configuration	current_config_ = {Direction::INPUT, Pull::NONE}
bool	has_config_ = false
std::atomic< bool >	interrupt_enabled_ {false}
std::atomic< bool >	interrupt_thread_started_ {false}
std::atomic< bool >	interrupt_thread_exit_ {false}
std::atomic< bool >	interrupt_poll_active_ {false}
Thread	interrupt_thread_
int	interrupt_wake_pipe_ [2] = {-1, -1}

Static Private Attributes
static constexpr size_t	EVENT_BUFFER_CAPACITY = 64
static constexpr size_t	INTERRUPT_THREAD_STACK_SIZE = 16384

Additional Inherited Members
Public Types inherited from LibXR::GPIO
enum class	Direction : uint8_t {   INPUT , OUTPUT_PUSH_PULL , OUTPUT_OPEN_DRAIN , FALL_INTERRUPT ,   RISING_INTERRUPT , FALL_RISING_INTERRUPT }
	定义 GPIO 引脚的方向类型。Defines the direction types for GPIO pins. More...
enum class	Pull : uint8_t { NONE , UP , DOWN }
	定义 GPIO 引脚的上拉/下拉模式。Defines the pull-up/pull-down configurations for GPIO pins. More...
using	Callback = LibXR::Callback<>
Data Fields inherited from LibXR::GPIO
Callback	callback_
	GPIO 事件的回调函数。Callback function for GPIO events.

Detailed Description

基于 Linux GPIO character device uAPI 的 Linux GPIO 实现 Linux GPIO implementation based on the Linux GPIO character-device uAPI

Note

优先使用 GPIO chardev v2；旧内核仅在需要时回退到 v1。

Prefer GPIO chardev v2; fall back to v1 only on older kernels.

当前运行级验证聚焦在 chardev v2；v1 fallback 目前仅作为兼容路径保留。

Runtime validation currently focuses on chardev v2; the v1 fallback is kept as a compatibility path.

Definition at line 25 of file linux_gpio.hpp.

Member Enumeration Documentation

AbiVersion

enum class LibXR::LinuxGPIO::AbiVersion : uint8_t

strongprivate

Definition at line 44 of file linux_gpio.hpp.

  {
    UNKNOWN = 0,
    V2 = 1,
    V1 = 2,
  };

RequestKind

enum class LibXR::LinuxGPIO::RequestKind : uint8_t

strongprivate

Definition at line 51 of file linux_gpio.hpp.

  {
    NONE = 0,
    HANDLE = 1,
    EVENT = 2,
  };

Constructor & Destructor Documentation

LinuxGPIO()

LibXR::LinuxGPIO::LinuxGPIO	(	const std::string &	chip_path,
		unsigned int	line_offset )

Definition at line 295 of file linux_gpio.cpp.

    : chip_path_(chip_path), line_offset_(line_offset)
{
  UNUSED(InitInterruptWakePipe());
  UNUSED(OpenChip());
}

~LinuxGPIO()

LibXR::LinuxGPIO::~LinuxGPIO ( )

override

Definition at line 302 of file linux_gpio.cpp.

{
  interrupt_thread_exit_.store(true);
  request_kind_.store(RequestKind::NONE);
  interrupt_enabled_.store(false);
  NotifyInterruptThread();
  WaitForInterruptThreadStopped();
  CloseRequest();
  CloseChip();
  CloseInterruptWakePipe();
}

Member Function Documentation

CloseChip()

void LibXR::LinuxGPIO::CloseChip ( )

private

Definition at line 587 of file linux_gpio.cpp.

{
  if (chip_fd_ >= 0)
  {
    close(chip_fd_);
    chip_fd_ = -1;
  }
  abi_version_.store(AbiVersion::UNKNOWN);
}

CloseInterruptWakePipe()

void LibXR::LinuxGPIO::CloseInterruptWakePipe ( )

private

Definition at line 640 of file linux_gpio.cpp.

{
  for (int& fd : interrupt_wake_pipe_)
  {
    if (fd >= 0)
    {
      close(fd);
      fd = -1;
    }
  }
}

CloseRequest()

void LibXR::LinuxGPIO::CloseRequest ( )

private

Definition at line 597 of file linux_gpio.cpp.

{
  request_kind_.store(RequestKind::NONE);
  interrupt_enabled_.store(false);
  NotifyInterruptThread();
  WaitForInterruptLoopIdle();
 
  const int request_fd = request_fd_.exchange(-1);
  if (request_fd >= 0)
  {
    close(request_fd);
  }
 
  request_kind_.store(RequestKind::NONE);
  interrupt_enabled_.store(false);
  has_config_ = false;
}

DetectAbiVersion()

ErrorCode LibXR::LinuxGPIO::DetectAbiVersion ( )

private

Definition at line 724 of file linux_gpio.cpp.

{
  if (abi_version_.load() != AbiVersion::UNKNOWN)
  {
    return ErrorCode::OK;
  }
 
  gpiochip_info chip_info = {};
  if (ioctl(chip_fd_, GPIO_GET_CHIPINFO_IOCTL, &chip_info) < 0)
  {
    XR_LOG_ERROR("Failed to read GPIO chip info: %s", std::strerror(errno));
    return ErrorCode::FAILED;
  }
 
  if (chip_info.lines == 0U)
  {
    XR_LOG_ERROR("GPIO chip exposes zero lines");
    return ErrorCode::FAILED;
  }
 
#if XR_LINUX_GPIO_HAS_V2
  gpio_v2_line_info info = {};
  info.offset = (line_offset_ < chip_info.lines) ? line_offset_ : 0U;
  if (ioctl(chip_fd_, GPIO_V2_GET_LINEINFO_IOCTL, &info) == 0)
  {
    abi_version_.store(AbiVersion::V2);
    return ErrorCode::OK;
  }
 
  if ((errno == ENOTTY) || (errno == EINVAL)
#ifdef EOPNOTSUPP
      || (errno == EOPNOTSUPP)
#endif
  )
  {
    abi_version_.store(AbiVersion::V1);
    return ErrorCode::OK;
  }
 
  XR_LOG_ERROR("Failed to probe GPIO chardev ABI: %s", std::strerror(errno));
  return ErrorCode::FAILED;
#else
  abi_version_.store(AbiVersion::V1);
  return ErrorCode::OK;
#endif
}

DisableInterrupt()

ErrorCode LibXR::LinuxGPIO::DisableInterrupt ( )

overridevirtual

禁用 GPIO 引脚中断。Disables the GPIO pin interrupt.

Returns

操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::GPIO.

Definition at line 423 of file linux_gpio.cpp.

{
  if (EnsureConfigured() != ErrorCode::OK)
  {
    return ErrorCode::STATE_ERR;
  }
 
  if (!IsInterruptDirection(current_config_.direction))
  {
    return ErrorCode::ARG_ERR;
  }
 
  if (!interrupt_enabled_.load())
  {
    return ErrorCode::OK;
  }
 
  const Configuration inactive_config = ResolveRequestConfig(current_config_, false);
  ErrorCode ec = ErrorCode::OK;
  if (NeedsRequestReopen(inactive_config))
  {
    ec = ReopenRequest(inactive_config);
  }
  else if (abi_version_.load() == AbiVersion::V2)
  {
    ec = ReconfigureRequestV2(inactive_config);
  }
  else
  {
    ec = ReconfigureRequestV1(inactive_config);
  }
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  has_config_ = true;
  interrupt_enabled_.store(false);
  return ErrorCode::OK;
}

EnableInterrupt()

ErrorCode LibXR::LinuxGPIO::EnableInterrupt ( )

overridevirtual

使能 GPIO 引脚中断。Enables the GPIO pin interrupt.

Returns

操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::GPIO.

Definition at line 382 of file linux_gpio.cpp.

{
  if (EnsureConfigured() != ErrorCode::OK)
  {
    return ErrorCode::STATE_ERR;
  }
 
  if (!IsInterruptDirection(current_config_.direction))
  {
    return ErrorCode::ARG_ERR;
  }
 
  if (interrupt_enabled_.load())
  {
    return ErrorCode::OK;
  }
 
  ErrorCode ec = ErrorCode::OK;
  if (NeedsRequestReopen(current_config_))
  {
    ec = ReopenRequest(current_config_);
  }
  else if (abi_version_.load() == AbiVersion::V2)
  {
    ec = ReconfigureRequestV2(current_config_);
  }
  else
  {
    ec = ReconfigureRequestV1(current_config_);
  }
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  has_config_ = true;
  interrupt_enabled_.store(true);
  StartInterruptThread();
  return ErrorCode::OK;
}

EnsureConfigured()

ErrorCode LibXR::LinuxGPIO::EnsureConfigured ( ) const

private

Definition at line 1058 of file linux_gpio.cpp.

{
  if (!has_config_ || (request_fd_.load() < 0))
  {
    XR_LOG_ERROR("GPIO is not configured");
    ASSERT(false);
    return ErrorCode::STATE_ERR;
  }
 
  return ErrorCode::OK;
}

InitInterruptWakePipe()

ErrorCode LibXR::LinuxGPIO::InitInterruptWakePipe ( )

private

Definition at line 615 of file linux_gpio.cpp.

{
  if (interrupt_wake_pipe_[0] >= 0)
  {
    return ErrorCode::OK;
  }
 
  if (pipe(interrupt_wake_pipe_) < 0)
  {
    XR_LOG_ERROR("Failed to create GPIO interrupt wake pipe: %s", std::strerror(errno));
    return ErrorCode::INIT_ERR;
  }
 
  if ((SetNonBlocking(interrupt_wake_pipe_[0]) < 0) ||
      (SetNonBlocking(interrupt_wake_pipe_[1]) < 0))
  {
    XR_LOG_ERROR("Failed to configure GPIO interrupt wake pipe: %s",
                 std::strerror(errno));
    CloseInterruptWakePipe();
    return ErrorCode::INIT_ERR;
  }
 
  return ErrorCode::OK;
}

InterruptLoop()

void LibXR::LinuxGPIO::InterruptLoop ( )

private

Definition at line 522 of file linux_gpio.cpp.

{
  while (!interrupt_thread_exit_.load())
  {
    if (!interrupt_enabled_.load())
    {
      Thread::Sleep(1);
      continue;
    }
 
    if (request_kind_.load() != RequestKind::EVENT)
    {
      Thread::Sleep(1);
      continue;
    }
 
    const int fd = request_fd_.load();
    if (fd < 0)
    {
      Thread::Sleep(1);
      continue;
    }
 
    size_t event_count = 0;
    interrupt_poll_active_.store(true);
    const ErrorCode pump = PumpEventQueue(fd, abi_version_.load(), event_count, 100);
    interrupt_poll_active_.store(false);
    if (pump == ErrorCode::OK)
    {
      for (size_t i = 0; i < event_count; ++i)
      {
        callback_.Run(false);
      }
      continue;
    }
 
    if (pump != ErrorCode::EMPTY)
    {
      Thread::Sleep(1);
    }
  }
 
  interrupt_poll_active_.store(false);
  interrupt_thread_started_.store(false);
}

IsInterruptDirection()

bool LibXR::LinuxGPIO::IsInterruptDirection ( Direction direction )

staticprivate

Definition at line 1069 of file linux_gpio.cpp.

{
  return direction == Direction::RISING_INTERRUPT ||
         direction == Direction::FALL_INTERRUPT ||
         direction == Direction::FALL_RISING_INTERRUPT;
}

NeedsRequestReopen()

bool LibXR::LinuxGPIO::NeedsRequestReopen ( Configuration config ) const

private

Definition at line 1076 of file linux_gpio.cpp.

{
  if (request_fd_.load() < 0)
  {
    return true;
  }
 
  const bool old_interrupt =
      interrupt_enabled_.load() && IsInterruptDirection(current_config_.direction);
  const bool new_interrupt = IsInterruptDirection(config.direction);
 
  if (abi_version_.load() == AbiVersion::V2)
  {
    return old_interrupt != new_interrupt;
  }
 
  if (new_interrupt)
  {
    return true;
  }
 
  if (old_interrupt)
  {
    return true;
  }
 
  return request_kind_.load() != RequestKind::HANDLE;
}

NotifyInterruptThread()

void LibXR::LinuxGPIO::NotifyInterruptThread ( )

private

Definition at line 652 of file linux_gpio.cpp.

{
  if (interrupt_wake_pipe_[1] < 0)
  {
    return;
  }
 
  const uint8_t signal = 1U;
  while (true)
  {
    const ssize_t ret = write(interrupt_wake_pipe_[1], &signal, sizeof(signal));
    if (ret >= 0)
    {
      return;
    }
 
    if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
    {
      DrainInterruptWakeFd(interrupt_wake_pipe_[0]);
      continue;
    }
 
    if (errno == EINTR)
    {
      continue;
    }
 
    return;
  }
}

OpenChip()

ErrorCode LibXR::LinuxGPIO::OpenChip ( )

private

Definition at line 568 of file linux_gpio.cpp.

{
  if (chip_fd_ >= 0)
  {
    return ErrorCode::OK;
  }
 
  chip_fd_ = open(chip_path_.c_str(), O_RDONLY | O_CLOEXEC);
  if (chip_fd_ < 0)
  {
    XR_LOG_ERROR("Failed to open GPIO chip: %s (%s)", chip_path_.c_str(),
                 std::strerror(errno));
    ASSERT(false);
    return ErrorCode::INIT_ERR;
  }
 
  return DetectAbiVersion();
}

OpenRequestV1()

ErrorCode LibXR::LinuxGPIO::OpenRequestV1 ( Configuration config )

private

Definition at line 855 of file linux_gpio.cpp.

{
  if (IsInterruptDirection(config.direction))
  {
    gpioevent_request request = {};
    request.lineoffset = line_offset_;
    request.handleflags = BuildHandleFlagsV1(config);
    request.eventflags = BuildEventFlagsV1(config.direction);
    CopyConsumer(request.consumer_label, LINUX_GPIO_CONSUMER);
 
    if (ioctl(chip_fd_, GPIO_GET_LINEEVENT_IOCTL, &request) < 0)
    {
      XR_LOG_ERROR("Failed to request GPIO event line (v1): %s", std::strerror(errno));
      return ErrorCode::FAILED;
    }
 
    request_fd_.store(request.fd);
    request_kind_.store(RequestKind::EVENT);
  }
  else
  {
    gpiohandle_request request = {};
    request.lineoffsets[0] = line_offset_;
    request.lines = 1U;
    request.flags = BuildHandleFlagsV1(config);
    CopyConsumer(request.consumer_label, LINUX_GPIO_CONSUMER);
 
    if (ioctl(chip_fd_, GPIO_GET_LINEHANDLE_IOCTL, &request) < 0)
    {
      XR_LOG_ERROR("Failed to request GPIO handle line (v1): %s", std::strerror(errno));
      return ErrorCode::FAILED;
    }
 
    request_fd_.store(request.fd);
    request_kind_.store(RequestKind::HANDLE);
  }
 
  if (SetNonBlocking(request_fd_.load()) < 0)
  {
    XR_LOG_ERROR("Failed to enable non-blocking GPIO request fd: %s",
                 std::strerror(errno));
    CloseRequest();
    return ErrorCode::FAILED;
  }
 
  return ErrorCode::OK;
}

OpenRequestV2()

ErrorCode LibXR::LinuxGPIO::OpenRequestV2 ( Configuration config )

private

Definition at line 783 of file linux_gpio.cpp.

{
#if XR_LINUX_GPIO_HAS_V2
  gpio_v2_line_request request = {};
  request.offsets[0] = line_offset_;
  request.num_lines = 1U;
  request.event_buffer_size =
      IsInterruptDirection(config.direction) ? EVENT_BUFFER_CAPACITY : 0U;
  CopyConsumer(request.consumer, LINUX_GPIO_CONSUMER);
  request.config.flags = BuildLineFlagsV2(config);
 
  if (ioctl(chip_fd_, GPIO_V2_GET_LINE_IOCTL, &request) < 0)
  {
    XR_LOG_ERROR("Failed to request GPIO line (v2): %s", std::strerror(errno));
    return ErrorCode::FAILED;
  }
 
  request_fd_.store(request.fd);
  request_kind_.store(IsInterruptDirection(config.direction) ? RequestKind::EVENT
                                                             : RequestKind::HANDLE);
  if (SetNonBlocking(request.fd) < 0)
  {
    XR_LOG_ERROR("Failed to enable non-blocking GPIO request fd: %s",
                 std::strerror(errno));
    CloseRequest();
    return ErrorCode::FAILED;
  }
 
  return ErrorCode::OK;
#else
  (void)config;
  ASSERT(false);
  return ErrorCode::FAILED;
#endif
}

PumpEventQueue()

ErrorCode LibXR::LinuxGPIO::PumpEventQueue ( int fd, AbiVersion abi_version, size_t & event_count, int timeout_ms ) const

private

Definition at line 925 of file linux_gpio.cpp.

{
  if (fd < 0)
  {
    return ErrorCode::STATE_ERR;
  }
 
  const PollReadableResult ready = PollReadable(fd, interrupt_wake_pipe_[0], timeout_ms);
  if (ready == PollReadableResult::ERROR)
  {
    if (errno == EBADF)
    {
      return ErrorCode::EMPTY;
    }
    XR_LOG_ERROR("Failed to poll GPIO fd: %s", std::strerror(errno));
    return ErrorCode::FAILED;
  }
 
  if ((ready == PollReadableResult::TIMEOUT) || (ready == PollReadableResult::WAKE))
  {
    return ErrorCode::EMPTY;
  }
 
  if (abi_version == AbiVersion::V2)
  {
    return ReadEventsV2(fd, event_count);
  }
 
  return ReadEventsV1(fd, event_count);
}

Read()

bool LibXR::LinuxGPIO::Read ( )

overridevirtual

读取 GPIO 引脚状态。Reads the GPIO pin state.

Returns

返回引脚状态，true 表示高电平，false 表示低电平。Returns the pin state, true for high, false for low.

Implements LibXR::GPIO.

Definition at line 314 of file linux_gpio.cpp.

{
  if (EnsureConfigured() != ErrorCode::OK)
  {
    return false;
  }
 
  const int request_fd = request_fd_.load();
  if (abi_version_.load() == AbiVersion::V2)
  {
#if XR_LINUX_GPIO_HAS_V2
    gpio_v2_line_values values = {};
    values.mask = 1ULL;
    if (ioctl(request_fd, GPIO_V2_LINE_GET_VALUES_IOCTL, &values) < 0)
    {
      XR_LOG_ERROR("Failed to read GPIO value: %s", std::strerror(errno));
      return false;
    }
    return (values.bits & 1ULL) != 0U;
#else
    ASSERT(false);
    return false;
#endif
  }
 
  gpiohandle_data values = {};
  if (ioctl(request_fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &values) < 0)
  {
    XR_LOG_ERROR("Failed to read GPIO value: %s", std::strerror(errno));
    return false;
  }
 
  return values.values[0] != 0U;
}

ReadEventsV1()

ErrorCode LibXR::LinuxGPIO::ReadEventsV1 ( int fd, size_t & event_count ) const

private

Definition at line 1013 of file linux_gpio.cpp.

{
  bool received = false;
  while (true)
  {
    gpioevent_data event = {};
    const ssize_t bytes = read(fd, &event, sizeof(event));
    if (bytes < 0)
    {
      if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
      {
        break;
      }
      if (errno == EBADF)
      {
        return received ? ErrorCode::OK : ErrorCode::EMPTY;
      }
 
      XR_LOG_ERROR("Failed to read GPIO v1 events: %s", std::strerror(errno));
      return ErrorCode::FAILED;
    }
 
    if (bytes == 0)
    {
      break;
    }
 
    if (bytes != static_cast<ssize_t>(sizeof(event)))
    {
      XR_LOG_ERROR("Corrupted GPIO v1 event payload length");
      return ErrorCode::FAILED;
    }
 
    if (!IsKnownGPIOEvent(event.id))
    {
      continue;
    }
 
    ++event_count;
    received = true;
  }
 
  return received ? ErrorCode::OK : ErrorCode::EMPTY;
}

ReadEventsV2()

ErrorCode LibXR::LinuxGPIO::ReadEventsV2 ( int fd, size_t & event_count ) const

private

Definition at line 957 of file linux_gpio.cpp.

{
#if XR_LINUX_GPIO_HAS_V2
  bool received = false;
  while (true)
  {
    std::array<gpio_v2_line_event, EVENT_BUFFER_CAPACITY> events = {};
    const ssize_t bytes = read(fd, events.data(), sizeof(events));
    if (bytes < 0)
    {
      if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
      {
        break;
      }
      if (errno == EBADF)
      {
        return received ? ErrorCode::OK : ErrorCode::EMPTY;
      }
 
      XR_LOG_ERROR("Failed to read GPIO v2 events: %s", std::strerror(errno));
      return ErrorCode::FAILED;
    }
 
    if (bytes == 0)
    {
      break;
    }
 
    if ((bytes % static_cast<ssize_t>(sizeof(gpio_v2_line_event))) != 0)
    {
      XR_LOG_ERROR("Corrupted GPIO v2 event payload length");
      return ErrorCode::FAILED;
    }
 
    const size_t count = static_cast<size_t>(bytes / sizeof(gpio_v2_line_event));
    for (size_t i = 0; i < count; ++i)
    {
      if (!IsKnownGPIOEvent(events[i].id))
      {
        continue;
      }
 
      ++event_count;
      received = true;
    }
  }
 
  return received ? ErrorCode::OK : ErrorCode::EMPTY;
#else
  (void)fd;
  event_count = 0U;
  ASSERT(false);
  return ErrorCode::FAILED;
#endif
}

ReconfigureRequestV1()

ErrorCode LibXR::LinuxGPIO::ReconfigureRequestV1 ( Configuration config )

private

Definition at line 903 of file linux_gpio.cpp.

{
  if (request_kind_.load() != RequestKind::HANDLE)
  {
    return ReopenRequest(config);
  }
 
#if XR_LINUX_GPIO_V1_HAS_SET_CONFIG
  gpiohandle_config handle_config = {};
  handle_config.flags = BuildHandleFlagsV1(config);
  if (ioctl(request_fd_.load(), GPIOHANDLE_SET_CONFIG_IOCTL, &handle_config) < 0)
  {
    XR_LOG_ERROR("Failed to reconfigure GPIO line (v1): %s", std::strerror(errno));
    return ErrorCode::FAILED;
  }
 
  return ErrorCode::OK;
#else
  return ReopenRequest(config);
#endif
}

ReconfigureRequestV2()

ErrorCode LibXR::LinuxGPIO::ReconfigureRequestV2 ( Configuration config )

private

Definition at line 819 of file linux_gpio.cpp.

{
#if XR_LINUX_GPIO_HAS_V2
  const bool was_interrupt_request =
      (request_kind_.load() == RequestKind::EVENT) && interrupt_enabled_.load();
  if (was_interrupt_request)
  {
    request_kind_.store(RequestKind::NONE);
    interrupt_enabled_.store(false);
    NotifyInterruptThread();
    WaitForInterruptLoopIdle();
  }
 
  gpio_v2_line_config line_config = {};
  line_config.flags = BuildLineFlagsV2(config);
 
  if (ioctl(request_fd_.load(), GPIO_V2_LINE_SET_CONFIG_IOCTL, &line_config) < 0)
  {
    XR_LOG_ERROR("Failed to reconfigure GPIO line (v2): %s", std::strerror(errno));
    return ErrorCode::FAILED;
  }
 
  request_kind_.store(IsInterruptDirection(config.direction) ? RequestKind::EVENT
                                                             : RequestKind::HANDLE);
  if (was_interrupt_request && IsInterruptDirection(config.direction))
  {
    interrupt_enabled_.store(true);
  }
  return ErrorCode::OK;
#else
  (void)config;
  ASSERT(false);
  return ErrorCode::FAILED;
#endif
}

ReopenRequest()

ErrorCode LibXR::LinuxGPIO::ReopenRequest ( Configuration config )

private

Definition at line 771 of file linux_gpio.cpp.

{
  CloseRequest();
 
  if (abi_version_.load() == AbiVersion::V2)
  {
    return OpenRequestV2(config);
  }
 
  return OpenRequestV1(config);
}

SetConfig()

ErrorCode LibXR::LinuxGPIO::SetConfig ( Configuration config )

overridevirtual

配置 GPIO 引脚参数。Configures the GPIO pin settings.

Parameters

config

需要应用的 GPIO 配置。The GPIO configuration to apply.

Returns

操作结果的错误码。Error code indicating the result of the operation.

Implements LibXR::GPIO.

Definition at line 464 of file linux_gpio.cpp.

{
  const ErrorCode chip_ready = OpenChip();
  if (chip_ready != ErrorCode::OK)
  {
    return chip_ready;
  }
 
  const bool keep_interrupt_enabled =
      interrupt_enabled_.load() && IsInterruptDirection(config.direction);
  const Configuration request_config =
      ResolveRequestConfig(config, keep_interrupt_enabled);
 
  ErrorCode ec = ErrorCode::OK;
  if (request_fd_.load() < 0)
  {
    ec = ReopenRequest(request_config);
  }
  else if (NeedsRequestReopen(request_config))
  {
    ec = ReopenRequest(request_config);
  }
  else if (abi_version_.load() == AbiVersion::V2)
  {
    ec = ReconfigureRequestV2(request_config);
  }
  else
  {
    ec = ReconfigureRequestV1(request_config);
  }
 
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  current_config_ = config;
  has_config_ = true;
  interrupt_enabled_.store(keep_interrupt_enabled);
  if (keep_interrupt_enabled)
  {
    StartInterruptThread();
  }
  return ErrorCode::OK;
}

StartInterruptThread()

void LibXR::LinuxGPIO::StartInterruptThread ( )

private

Definition at line 510 of file linux_gpio.cpp.

{
  if (interrupt_thread_started_.exchange(true))
  {
    return;
  }
 
  interrupt_thread_.Create<LinuxGPIO*>(
      this, [](LinuxGPIO* self) { self->InterruptLoop(); }, "irq_gpio",
      INTERRUPT_THREAD_STACK_SIZE, Thread::Priority::MEDIUM);
}

WaitForInterruptLoopIdle()

void LibXR::LinuxGPIO::WaitForInterruptLoopIdle ( )

private

Definition at line 683 of file linux_gpio.cpp.

{
  if (!interrupt_thread_started_.load())
  {
    return;
  }
 
  for (uint32_t i = 0; i < 200; ++i)
  {
    if (!interrupt_poll_active_.load())
    {
      return;
    }
 
    Thread::Sleep(1);
  }
 
  XR_LOG_WARN("Timed out waiting for GPIO interrupt loop to go idle");
}

WaitForInterruptThreadStopped()

void LibXR::LinuxGPIO::WaitForInterruptThreadStopped ( )

private

Definition at line 703 of file linux_gpio.cpp.

{
  if (!interrupt_thread_started_.load())
  {
    return;
  }
 
  for (uint32_t i = 0; i < 500; ++i)
  {
    if (!interrupt_thread_started_.load())
    {
      return;
    }
 
    NotifyInterruptThread();
    Thread::Sleep(1);
  }
 
  XR_LOG_WARN("Timed out waiting for GPIO interrupt thread to stop");
}

Write()

void LibXR::LinuxGPIO::Write ( bool value )

overridevirtual

写入 GPIO 引脚状态。Writes the GPIO pin state.

Parameters

value

要写入的状态，true 表示高电平，false 表示低电平。The value to write, true for high, false for low.

Implements LibXR::GPIO.

Definition at line 349 of file linux_gpio.cpp.

{
  if (EnsureConfigured() != ErrorCode::OK)
  {
    return;
  }
 
  const int request_fd = request_fd_.load();
  if (abi_version_.load() == AbiVersion::V2)
  {
#if XR_LINUX_GPIO_HAS_V2
    gpio_v2_line_values values = {};
    values.mask = 1ULL;
    values.bits = value ? 1ULL : 0ULL;
    if (ioctl(request_fd, GPIO_V2_LINE_SET_VALUES_IOCTL, &values) < 0)
    {
      XR_LOG_WARN("Failed to write GPIO value: %s", std::strerror(errno));
    }
    return;
#else
    ASSERT(false);
    return;
#endif
  }
 
  gpiohandle_data values = {};
  values.values[0] = value ? 1U : 0U;
  if (ioctl(request_fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &values) < 0)
  {
    XR_LOG_WARN("Failed to write GPIO value: %s", std::strerror(errno));
  }
}

Field Documentation

abi_version_

std::atomic<AbiVersion> LibXR::LinuxGPIO::abi_version_ {AbiVersion::UNKNOWN}

private

Definition at line 62 of file linux_gpio.hpp.

{AbiVersion::UNKNOWN};

chip_fd_

int LibXR::LinuxGPIO::chip_fd_ = -1

private

Definition at line 60 of file linux_gpio.hpp.

chip_path_

std::string LibXR::LinuxGPIO::chip_path_

private

Definition at line 58 of file linux_gpio.hpp.

current_config_

Configuration LibXR::LinuxGPIO::current_config_ = {Direction::INPUT, Pull::NONE}

private

Definition at line 64 of file linux_gpio.hpp.

{Direction::INPUT, Pull::NONE};

EVENT_BUFFER_CAPACITY

size_t LibXR::LinuxGPIO::EVENT_BUFFER_CAPACITY = 64

staticconstexprprivate

Definition at line 41 of file linux_gpio.hpp.

has_config_

bool LibXR::LinuxGPIO::has_config_ = false

private

Definition at line 65 of file linux_gpio.hpp.

interrupt_enabled_

std::atomic<bool> LibXR::LinuxGPIO::interrupt_enabled_ {false}

private

Definition at line 66 of file linux_gpio.hpp.

{false};

interrupt_poll_active_

std::atomic<bool> LibXR::LinuxGPIO::interrupt_poll_active_ {false}

private

Definition at line 69 of file linux_gpio.hpp.

{false};

interrupt_thread_

Thread LibXR::LinuxGPIO::interrupt_thread_

private

Definition at line 70 of file linux_gpio.hpp.

interrupt_thread_exit_

std::atomic<bool> LibXR::LinuxGPIO::interrupt_thread_exit_ {false}

private

Definition at line 68 of file linux_gpio.hpp.

{false};

INTERRUPT_THREAD_STACK_SIZE

size_t LibXR::LinuxGPIO::INTERRUPT_THREAD_STACK_SIZE = 16384

staticconstexprprivate

Definition at line 42 of file linux_gpio.hpp.

interrupt_thread_started_

std::atomic<bool> LibXR::LinuxGPIO::interrupt_thread_started_ {false}

private

Definition at line 67 of file linux_gpio.hpp.

{false};

interrupt_wake_pipe_

int LibXR::LinuxGPIO::interrupt_wake_pipe_[2] = {-1, -1}

private

Definition at line 71 of file linux_gpio.hpp.

{-1, -1};

line_offset_

unsigned int LibXR::LinuxGPIO::line_offset_ = 0U

private

Definition at line 59 of file linux_gpio.hpp.

request_fd_

std::atomic<int> LibXR::LinuxGPIO::request_fd_ {-1}

private

Definition at line 61 of file linux_gpio.hpp.

{-1};

request_kind_

std::atomic<RequestKind> LibXR::LinuxGPIO::request_kind_ {RequestKind::NONE}

private

Definition at line 63 of file linux_gpio.hpp.

{RequestKind::NONE};

---

The documentation for this class was generated from the following files:

• driver/linux/linux_gpio.hpp
• driver/linux/linux_gpio.cpp