gpio2.h

/* Copyright © 2018-2025 Pascal JEAN, All rights reserved.
   This file is part of the Piduino Library.
 
   The Piduino Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
 
   The Piduino Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public License
   along with the Piduino Library; if not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
 
// based on https://gist.github.com/8c8678c65b884c62aca328a5bf57f4f5.git
 
#include <string>
#include <chrono>
#include <thread>
#include <stdexcept>
#include <system_error>
#include <iostream>
 
#include <cstring>
#include <cerrno>
#include <cstdint>
 
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/poll.h>
#include <linux/gpio.h>
 
#include <piduino/global.h>
 
namespace Gpio2 {
 
  class Line;
 
  #ifdef __DOXYGEN__
#define GPIO_MAX_NAME_SIZE 32
#define GPIO_V2_LINES_MAX 64
 
#define GPIO_V2_LINE_NUM_ATTRS_MAX 10
  enum gpio_v2_line_attr_id {
    GPIO_V2_LINE_ATTR_ID_FLAGS    = 1, 
    GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES  = 2, 
    GPIO_V2_LINE_ATTR_ID_DEBOUNCE   = 3, 
  };
 
  enum gpio_v2_line_flag {
    GPIO_V2_LINE_FLAG_USED      = _BITULL (0), 
    GPIO_V2_LINE_FLAG_ACTIVE_LOW    = _BITULL (1), 
    GPIO_V2_LINE_FLAG_INPUT     = _BITULL (2), 
    GPIO_V2_LINE_FLAG_OUTPUT    = _BITULL (3), 
    GPIO_V2_LINE_FLAG_EDGE_RISING   = _BITULL (4), 
    GPIO_V2_LINE_FLAG_EDGE_FALLING    = _BITULL (5), 
    GPIO_V2_LINE_FLAG_OPEN_DRAIN    = _BITULL (6), 
    GPIO_V2_LINE_FLAG_OPEN_SOURCE   = _BITULL (7), 
    GPIO_V2_LINE_FLAG_BIAS_PULL_UP    = _BITULL (8), 
    GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN  = _BITULL (9), 
    GPIO_V2_LINE_FLAG_BIAS_DISABLED   = _BITULL (10), 
    GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME  = _BITULL (11), 
    GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE = _BITULL (12), 
  };
 
  enum gpio_v2_line_event_id {
    GPIO_V2_LINE_EVENT_RISING_EDGE  = 1, 
    GPIO_V2_LINE_EVENT_FALLING_EDGE = 2, 
  };
  #endif
 
  struct ChipInfo : public ::gpiochip_info {
    ChipInfo() {
      memset (this, 0, sizeof (*this));
    }
 
    #ifdef __DOXYGEN__
    char name[GPIO_MAX_NAME_SIZE]; 
    char label[GPIO_MAX_NAME_SIZE]; 
    __u32 lines; 
    #endif
  };
 
  struct LineAttribute : public ::gpio_v2_line_attribute {
    LineAttribute() {
      memset (this, 0, sizeof (*this));
    }
 
    LineAttribute (uint32_t id) {
      memset (this, 0, sizeof (*this));
      this->id = id;
    }
    #ifdef __DOXYGEN__
    __u32 id; 
    __u32 padding; 
    union {
      __aligned_u64 flags;
      __aligned_u64 values;
      __u32 debounce_period_us;
    };
    #endif
  };
 
  struct LineInfo : public ::gpio_v2_line_info {
    LineInfo() {
      memset (this, 0, sizeof (*this));
    }
 
    LineInfo (uint32_t offset) {
      memset (this, 0, sizeof (*this));
      this->offset = offset;
    }
 
    void printAttributes (std::ostream &os = std::cout) const;
 
    friend std::ostream &operator<< (std::ostream &os, const LineInfo &info);
 
    #ifdef __DOXYGEN__
    char name[GPIO_MAX_NAME_SIZE];
    char consumer[GPIO_MAX_NAME_SIZE];
    __u32 offset;
    __u32 num_attrs;
    __aligned_u64 flags;
    struct LineAttribute attrs[GPIO_V2_LINE_NUM_ATTRS_MAX];
    __u32 padding[4];
    #endif
  };
 
  struct LineConfigAttribute : public ::gpio_v2_line_config_attribute {
    LineConfigAttribute() {
      memset (this, 0, sizeof (*this));
    }
 
    LineConfigAttribute (const LineAttribute &attr) {
      memset (this, 0, sizeof (*this));
      this->attr = attr;
    }
 
    #ifdef __DOXYGEN__
    struct LineAttribute attr;
    __aligned_u64 mask;
    #endif
  };
 
 
  struct LineConfig : public ::gpio_v2_line_config {
    LineConfig() {
      clear();
    }
 
    LineConfig (std::uint64_t flags) {
      clear();
      this->flags = flags;
    }
 
    void clear() {
      memset (this, 0, sizeof (*this));
    }
 
    #ifdef __DOXYGEN__
    __aligned_u64 flags;
    __u32 num_attrs;
    __u32 padding[5];
    struct LineConfigAttribute attrs[GPIO_V2_LINE_NUM_ATTRS_MAX];
    #endif
  };
 
  struct LineRequest : public ::gpio_v2_line_request {
    LineRequest() {
      memset (this, 0, sizeof (*this));
      num_lines = 0;
      event_buffer_size = 0;
      fd = -1;
    }
 
    LineRequest (const std::string &consumer) {
      memset (this, 0, sizeof (*this));
      strncpy (this->consumer, consumer.c_str(), GPIO_MAX_NAME_SIZE - 1);
      num_lines = 0;
      event_buffer_size = 0;
      fd = -1;
    }
 
    #ifdef __DOXYGEN__
    __u32 offsets[GPIO_V2_LINES_MAX];
    char consumer[GPIO_MAX_NAME_SIZE];
    struct LineConfig config;
    __u32 num_lines;
    __u32 event_buffer_size;
    __u32 padding[5];
    __s32 fd;
    #endif
  };
 
  struct LineValues : public ::gpio_v2_line_values {
    LineValues() {
      memset (this, 0, sizeof (*this));
    }
 
    LineValues (std::uint64_t bits, std::uint64_t mask) {
      memset (this, 0, sizeof (*this));
      this->bits = bits;
      this->mask = mask;
    }
 
    #ifdef __DOXYGEN__
    __aligned_u64 bits;
    __aligned_u64 mask;
    #endif
  };
 
  struct LineEvent : public ::gpio_v2_line_event {
    LineEvent() {
 
      memset (this, 0, sizeof (*this));
    }
 
    #ifdef __DOXYGEN__
    __aligned_u64 timestamp_ns;
    __u32 id;
    __u32 offset;
    __u32 seqno;
    __u32 line_seqno;
    __u32 padding[6];
    #endif
  };
 
  class Chip {
    public:
      Chip (const std::string &consumer = std::string()) : m_consumer (consumer), m_fd (-1), m_last_error (0), m_last_result (0) {}
 
      ~Chip() {
 
        // Ensure the chip is closed when the object is destroyed.
        close();
      }
 
      std::string consumer() const {
        return m_consumer;
      }
 
      template<class ParamType>
      bool ioCtl (unsigned long cmd, ParamType *param) {
 
        m_last_result = ::ioctl (m_fd, cmd, param);
        if (m_last_result == -1) {
 
          m_last_error = errno;
          return false;
        }
        m_last_error = 0;
        return true;
      }
 
      int errorCode() const {
 
        return m_last_error;
      }
 
      int result() const {
 
        return m_last_result;
      }
 
      const char *errorMessage() const {
 
        return strerror (errorCode());
      }
 
      bool open (const char *dev) {
 
        m_dev = dev;
        m_fd = ::open (dev, O_RDONLY);
        if (!isOpen()) {
 
          m_last_error = errno;
          return false;
        }
        m_last_error = 0;
        return true;
      }
 
      bool open (const std::string &dev) {
 
        return open (dev.c_str());
      }
 
      bool open (uint32_t chip_no) {
 
        // Open the GPIO chip device using the chip number.
        return open (devPath (chip_no));
      }
 
      bool isOpen() const {
 
        return m_fd != -1;
      }
 
      std::string  dev() const {
 
        return m_dev;
      }
 
      bool close() {
 
        if (isOpen()) {
          // Close the file descriptor and reset it
          // to -1 to indicate that the device is closed.
          m_last_result = ::close (m_fd);
          m_fd = -1;
          if (m_last_result == -1) {
 
            m_last_error = errno;
            return false;
          }
          m_last_error = 0;
        }
        return true;
      }
 
      bool fillInfo() {
 
        if (isOpen()) {
 
          return ioCtl (GPIO_GET_CHIPINFO_IOCTL, &m_dev_info);
        }
        return false;
      }
 
      std::string name() const {
 
        return m_dev_info.name;
      }
 
      std::string label() const {
 
        return m_dev_info.label;
      }
 
      uint32_t lines() const {
 
        return m_dev_info.lines;
      }
 
      bool lineInfo (uint32_t offset, LineInfo *info) {
 
        memset (info, 0, sizeof (*info));
        info->offset = offset;
        return ioCtl (GPIO_V2_GET_LINEINFO_IOCTL, info);
      }
 
      static std::string devPath (uint32_t chip_no) {
 
        return "/dev/gpiochip" + std::to_string (chip_no);
      }
 
    private:
      std::string m_dev;
      std::string m_consumer;
      ChipInfo m_dev_info;
      int m_fd;
      int m_last_error;
      int m_last_result;
  };
 
  class Line {
    public:
      Line (std::shared_ptr<Chip> dev, uint32_t offset) : Line (dev, 1, &offset) {}
 
      Line (std::shared_ptr<Chip> dev, uint32_t num_lines, const uint32_t *offsets) : m_chip (dev), m_req (dev->consumer()), m_last_error (0), m_last_result (0) {
 
        m_req.num_lines = num_lines;
        m_req.fd = -1;
        memcpy (m_req.offsets, offsets, num_lines * sizeof (uint32_t));
      }
 
      Line (std::shared_ptr<Chip> dev, const LineRequest &request) : m_chip (dev), m_req (request), m_last_error (0), m_last_result (0) {
 
        strncpy (m_req.consumer, dev->consumer().c_str(), sizeof (m_req.consumer));
      }
 
      ~Line() {
 
        close();
      }
 
      Line (const Line &) = delete;
      Line (Line &&) = delete;
      Line &operator= (const Line &) = delete;
      Line &operator= (Line &&) = delete;
 
      int errorCode() const {
 
        return m_last_error;
      }
 
      int result() const {
 
        return m_last_result;
      }
 
      const char *errorMessage() const {
 
        return strerror (errorCode());
      }
 
      const LineRequest &request() const {
 
        return m_req;
      }
 
      uint32_t numLines() const {
 
        return m_req.num_lines;
      }
 
      uint32_t offset (uint32_t line_no = 0) const {
 
        if (line_no >= m_req.num_lines) {
 
          throw std::out_of_range ("Line number out of range");
        }
        return m_req.offsets[line_no];
      }
 
      const LineConfig &config() const {
 
        return reinterpret_cast<const LineConfig &> (m_req.config);
      }
 
      bool getInfo (LineInfo *info, uint32_t num_lines = 1) {
 
        if (num_lines > m_req.num_lines) {
          num_lines = m_req.num_lines;
        }
 
        for (uint32_t i = 0; i < num_lines; ++i) {
 
          if (!m_chip->lineInfo (m_req.offsets[i], &info[i])) {
 
            m_last_error = m_chip->errorCode();
            m_last_result = m_chip->result();
            return false;
          }
          else {
 
            m_last_error = 0;
            m_last_result = 0;
          }
        }
        return true;
      }
 
      bool open (uint64_t flags) {
 
        if (m_chip->isOpen() && !isOpen()) {
 
          m_req.config.flags = flags;
          if (!m_chip->ioCtl (GPIO_V2_GET_LINE_IOCTL, &m_req)) {
 
            m_last_error = m_chip->errorCode();
            m_last_result = m_chip->result();
          }
          else  {
 
            m_last_error = 0;
            m_last_result = 0;
          }
        }
        return isOpen();
      }
 
      bool open (const LineConfig &config) {
 
        if (m_chip->isOpen() && !isOpen()) {
 
          m_req.config = config;
          if (!m_chip->ioCtl (GPIO_V2_GET_LINE_IOCTL, &m_req)) {
 
            m_last_error = m_chip->errorCode();
            m_last_result = m_chip->result();
          }
          else {
 
            m_last_error = 0;
            m_last_result = 0;
          }
        }
        return isOpen();
      }
 
      bool setConfig (const LineConfig &config) {
 
        m_req.config = config;
        if (isOpen()) {
 
          m_last_result = ::ioctl (m_req.fd, GPIO_V2_LINE_SET_CONFIG_IOCTL, &config);
          if (m_last_result == -1) {
 
            m_last_error = errno;
          }
          else {
            
            std::this_thread::sleep_for (std::chrono::microseconds (1)); // Allow time for the configuration to take effect
            m_last_error = 0;
          }
          return (m_last_result >= 0);
        }
        return false;
      }
 
      bool isOpen() const {
 
        return m_req.fd >= 0;
      }
 
      bool close() {
 
        if (isOpen()) {
          m_last_result = ::close (m_req.fd);
          m_req.fd = -1;
          if (m_last_result == -1) {
 
            m_last_error = errno;
          }
          else {
 
            m_last_error = 0;
          }
          return m_last_result == 0;
        }
        return false;
      }
 
      bool getValues (LineValues &values) const {
 
        if (isOpen()) {
 
          m_last_result = ::ioctl (m_req.fd, GPIO_V2_LINE_GET_VALUES_IOCTL, &values);
          if (m_last_result == -1) {
 
            m_last_error = errno;
          }
          else {
 
            m_last_error = 0;
          }
          return (m_last_result != -1);
        }
        return false;
      }
 
      bool getValue (int line_no = 0) const {
 
        if (isOpen()) {
          LineValues values (0, 1ULL << line_no);
 
          if (getValues (values)) {
 
            return ( (values.bits & values.mask) != 0);
          }
          else {
 
            throw std::system_error (errno, std::system_category(), EXCEPTION_MSG ("Failed to get line values"));
          }
        }
        return false;
      }
 
      bool setValue (bool value, int line_no = 0) {
 
        if (isOpen()) {
          uint64_t line_mask = 1ULL << line_no;
          LineValues values (value ? line_mask : 0, line_mask);
 
          return setValues (values);
        }
        return false;
      }
 
      bool setValues (const LineValues &values) {
 
        if (isOpen()) {
 
          m_last_result = ::ioctl (m_req.fd, GPIO_V2_LINE_SET_VALUES_IOCTL, &values);
          if (m_last_result == -1) {
 
            m_last_error = errno;
          }
          else {
 
            m_last_error = 0;
          }
          return (m_last_result != -1);
        }
        return false;
      }
 
      bool setDebounce (uint32_t debounce_ms) {
 
        if (debounce_ms != debounce()) {
          LineConfig cfg = * (reinterpret_cast<LineConfig *> (&m_req.config));
          auto &debounce = cfg.attrs[0];
 
          if (debounce_ms > 0) {
 
            debounce.attr.id = GPIO_V2_LINE_ATTR_ID_DEBOUNCE;
            debounce.attr.debounce_period_us = debounce_ms * 1000;
            debounce.mask |= 1ULL << 0;
            cfg.num_attrs = 1;
          }
          else {
 
            debounce.attr.id = GPIO_V2_LINE_ATTR_ID_DEBOUNCE;
            debounce.attr.debounce_period_us = 0;
            debounce.mask = 0;
            cfg.num_attrs = 0;
          }
 
          return setConfig (cfg);
        }
        return true;
      }
 
      uint32_t debounce() const {
 
        return m_req.config.attrs[0].attr.debounce_period_us / 1000;
      }
 
      bool waitForEvent (LineEvent &event, int timeout_ms = -1) {
 
        if (isOpen()) {
 
          pollfd pfd[1];
          pfd[0].fd = m_req.fd;
          pfd[0].events = POLLIN | POLLPRI;
 
          m_last_result = ::poll (pfd, 1, timeout_ms);
          if (m_last_result > 0) {
 
            m_last_result = ::read (m_req.fd, &event, sizeof (event));
            if (m_last_result == sizeof (event)) {
 
              m_last_error = 0;
              return true;
            }
          }
          m_last_error = errno;
        }
        return false;
      }
 
    private:
      std::shared_ptr<Chip> m_chip;
      LineRequest m_req;
      mutable int m_last_error;
      mutable int m_last_result;
  };
 
}