ra8_esp_hosted_gpio.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "esp_hosted_power_save.h"
#include "port_esp_hosted_host_config.h"
#include "port_esp_hosted_host_os.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_gpio_internal.h"
#include "ra8_esp_hosted_pins.h"
#include "ra8_icu_regs.h"
#include "ra8_log.h"
#include "ra8_pin_interface.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_reset.h"

static const char* const s_tag = "eh_gpio";

typedef enum : uint32_t {
  k_ra8_esp_hosted_gpio_pin_unwired = 0xFFFFFFFFU, 
} ra8_esp_hosted_gpio_sentinel_t;

typedef enum : uint32_t {
  k_ra8_esp_hosted_gpio_mode_input  = 0U, 
  k_ra8_esp_hosted_gpio_mode_output = 1U, 
} ra8_esp_hosted_gpio_mode_t;

typedef enum : uint32_t {
  k_ra8_esp_hosted_gpio_pull_up   = 0U, 
  k_ra8_esp_hosted_gpio_pull_down = 1U, 
} ra8_esp_hosted_gpio_pull_t;

typedef enum : uint8_t {
  k_ra8_esp_hosted_gpio_read_low  = 0U, 
  k_ra8_esp_hosted_gpio_read_high = 1U, 
} ra8_esp_hosted_gpio_read_t;
 
static_assert((uint32_t)k_ra8_esp_hosted_gpio_mode_input == (uint32_t)H_GPIO_MODE_DEF_INPUT,
              "input mode selector must match the vendored spelling");
static_assert((uint32_t)k_ra8_esp_hosted_gpio_mode_output == (uint32_t)H_GPIO_MODE_DEF_OUTPUT,
              "output mode selector must match the vendored spelling");
static_assert((uint32_t)k_ra8_esp_hosted_gpio_pull_up == (uint32_t)H_GPIO_PULL_UP,
              "pull-up selector must match the vendored spelling");
static_assert((uint32_t)k_ra8_esp_hosted_gpio_pull_down == (uint32_t)H_GPIO_PULL_DOWN,
              "pull-down selector must match the vendored spelling");
static_assert((uint8_t)H_HS_INTR_EDGE <= (uint8_t)k_ra8_icu_irqmd_low,
              "HANDSHAKE edge selector must be a legal ICU sense");
static_assert((uint8_t)H_DR_INTR_EDGE <= (uint8_t)k_ra8_icu_irqmd_low,
              "DATA_READY edge selector must be a legal ICU sense");

typedef struct ra8_esp_hosted_gpio_irq_row {
  void (*handler)(void* arg); 
  void*          arg;         
  ra8_port_pin_t pin;         
  uint8_t        irq_num;     
  bool           used;        
} ra8_esp_hosted_gpio_irq_row_t;

static ra8_esp_hosted_gpio_irq_row_t s_irq_rows[k_ra8_esp_hosted_gpio_row_max];

static const ra8_pin_interface_t* s_pin_if;
 
/*
 * The production pin driver is defined in libs/ra8_hal/src/gpio.c and, like
 * every other consumer of it in this tree, is reached by declaration rather
 * than through a header -- ra8_pin_interface.h describes the type, not the
 * instance.
 */
extern const ra8_pin_interface_t g_ra8_gpio_pin_interface;
 
RA8_PRIV bool priv_ra8_esp_hosted_gpio_decode_pin(const void*     gpio_port,
                                                  uint32_t        gpio_num,
                                                  ra8_port_pin_t* out_pin)
{
  if (out_pin == nullptr) {
    return false;
  }
  const uintptr_t port_idx = (uintptr_t)gpio_port;
  if ((gpio_num == (uint32_t)k_ra8_esp_hosted_gpio_pin_unwired) ||
      (port_idx > (uintptr_t)k_ra8_port_max) || (gpio_num > (uint32_t)k_ra8_pin_max)) {
    return false;
  }
  *out_pin = RA8_PIN((uint16_t)port_idx, (uint16_t)gpio_num);
  return true;
}
 
RA8_PRIV void priv_ra8_esp_hosted_gpio_set_pin_interface(const ra8_pin_interface_t* iface)
{
  s_pin_if = iface;
}
 
RA8_PRIV const ra8_pin_interface_t* priv_ra8_esp_hosted_gpio_pin_interface(void)
{
  return (s_pin_if != nullptr) ? s_pin_if : &g_ra8_gpio_pin_interface;
}

RA8_INTERNAL
static uint8_t internal_irq_find(ra8_port_pin_t pin)
{
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_gpio_row_max; i++) {
    if (s_irq_rows[i].used && (s_irq_rows[i].pin == pin)) {
      return i;
    }
  }
  return (uint8_t)k_ra8_esp_hosted_gpio_row_max;
}

RA8_INTERNAL
static uint8_t internal_irq_alloc(void)
{
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_esp_hosted_gpio_row_max; i++) {
    if (!s_irq_rows[i].used) {
      return i;
    }
  }
  return (uint8_t)k_ra8_esp_hosted_gpio_row_max;
}

RA8_INTERNAL RA8_ISR_SAFE static void internal_isr_trampoline(void* ctx)
{
  const ra8_esp_hosted_gpio_irq_row_t* row = (const ra8_esp_hosted_gpio_irq_row_t*)ctx;
  row->handler(row->arg);
}

RA8_INTERNAL
static ra8_err_t internal_attach_hardware(ra8_port_pin_t pin,
                                          uint8_t        irq_num,
                                          uint8_t        sense,
                                          void (*handler)(void*),
                                          void* arg)
{
  const uint8_t slot = internal_irq_alloc();
  if (slot >= (uint8_t)k_ra8_esp_hosted_gpio_row_max) {
    return k_ra8_err_no_mem;
  }
  s_irq_rows[slot].pin     = pin;
  s_irq_rows[slot].handler = handler;
  s_irq_rows[slot].arg     = arg;
  s_irq_rows[slot].irq_num = irq_num;
  s_irq_rows[slot].used    = true;
 
  const ra8_gpio_irq_cfg_t cfg = {
    .pull       = k_ra8_pull_none,
    .sense      = (ra8_icu_irqmd_t)sense,
    .filter_div = k_ra8_icu_fclksel_pclkb,
    .filter_en  = false,
    .priority   = (uint8_t)k_ra8_esp_hosted_gpio_irq_priority,
  };
  const ra8_err_t err =
    ra8_gpio_attach_irq(pin, irq_num, &cfg, internal_isr_trampoline, &s_irq_rows[slot]);
  if (err != k_ra8_ok) {
    s_irq_rows[slot] = (ra8_esp_hosted_gpio_irq_row_t){};
    ra8_log_error_val(s_tag, "attach_irq failed", (uint32_t)err);
  }
  return err;
}

RA8_INTERNAL
static int internal_config_gpio(void* gpio_port, uint32_t gpio_num, uint32_t mode)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  if (!priv_ra8_esp_hosted_gpio_decode_pin(gpio_port, gpio_num, &pin)) {
    return RET_INVALID;
  }
  ra8_err_t err = k_ra8_err_invalid_arg;
  if (mode == (uint32_t)k_ra8_esp_hosted_gpio_mode_output) {
    const ra8_pin_interface_t* pin_if = priv_ra8_esp_hosted_gpio_pin_interface();
    err = pin_if->output_init(pin_if->ctx, pin, (ra8_level_t)H_RESET_VAL_INACTIVE);
  } else if (mode == (uint32_t)k_ra8_esp_hosted_gpio_mode_input) {
    err = ra8_gpio_input_init(pin, k_ra8_pull_none);
  } else {
    return RET_INVALID;
  }
  return (err == k_ra8_ok) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL
static int internal_config_gpio_as_interrupt(void*    gpio_port,
                                             uint32_t gpio_num,
                                             uint32_t intr_type,
                                             void (*gpio_isr_handler)(void* arg),
                                             void* arg)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  if (!priv_ra8_esp_hosted_gpio_decode_pin(gpio_port, gpio_num, &pin)) {
    return RET_INVALID;
  }
  if (gpio_isr_handler == nullptr) {
    return RET_INVALID;
  }
  if (intr_type > (uint32_t)k_ra8_icu_irqmd_low) {
    return RET_INVALID;
  }
  if (internal_irq_find(pin) < (uint8_t)k_ra8_esp_hosted_gpio_row_max) {
    return RET_FAIL;
  }
 
  const uint8_t   irq_num = ra8_esp_hosted_pin_irq_num(pin);
  const uint8_t   sense   = (uint8_t)intr_type;
  const ra8_err_t err =
    (irq_num == (uint8_t)k_ra8_esp_hosted_irq_none)
      ? priv_ra8_esp_hosted_gpio_edge_register(pin, sense, gpio_isr_handler, arg)
      : internal_attach_hardware(pin, irq_num, sense, gpio_isr_handler, arg);
  return (err == k_ra8_ok) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL
static int internal_teardown_gpio_interrupt(void* gpio_port, uint32_t gpio_num)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  if (!priv_ra8_esp_hosted_gpio_decode_pin(gpio_port, gpio_num, &pin)) {
    return RET_INVALID;
  }
  const uint8_t slot = internal_irq_find(pin);
  if (slot >= (uint8_t)k_ra8_esp_hosted_gpio_row_max) {
    return (priv_ra8_esp_hosted_gpio_edge_unregister(pin) == k_ra8_ok) ? RET_OK : RET_FAIL;
  }
  const ra8_err_t err = ra8_gpio_detach_irq(pin, s_irq_rows[slot].irq_num);
  s_irq_rows[slot]    = (ra8_esp_hosted_gpio_irq_row_t){};
  return (err == k_ra8_ok) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL
static int internal_read_gpio(void* gpio_port, uint32_t gpio_num)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  if (!priv_ra8_esp_hosted_gpio_decode_pin(gpio_port, gpio_num, &pin)) {
    return RET_INVALID;
  }
  const ra8_pin_interface_t* pin_if = priv_ra8_esp_hosted_gpio_pin_interface();
  ra8_level_t                level  = k_ra8_level_low;
  if (pin_if->read(pin_if->ctx, pin, &level) != k_ra8_ok) {
    return RET_FAIL;
  }
  return (level == k_ra8_level_high) ? (int)k_ra8_esp_hosted_gpio_read_high
                                     : (int)k_ra8_esp_hosted_gpio_read_low;
}

RA8_INTERNAL
static int internal_write_gpio(void* gpio_port, uint32_t gpio_num, uint32_t value)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  if (!priv_ra8_esp_hosted_gpio_decode_pin(gpio_port, gpio_num, &pin)) {
    return RET_INVALID;
  }
  const ra8_pin_interface_t* pin_if = priv_ra8_esp_hosted_gpio_pin_interface();
  const ra8_level_t          level  = (value != 0U) ? k_ra8_level_high : k_ra8_level_low;
  return (pin_if->write(pin_if->ctx, pin, level) == k_ra8_ok) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL
static int
internal_pull_gpio(void* gpio_port, uint32_t gpio_num, uint32_t pull_value, uint32_t enable)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  if (!priv_ra8_esp_hosted_gpio_decode_pin(gpio_port, gpio_num, &pin)) {
    return RET_INVALID;
  }
  if (pull_value == (uint32_t)k_ra8_esp_hosted_gpio_pull_down) {
    ra8_log_warn(s_tag, "pull-down requested; RA8D2 PFS has no pull-down bit");
    return RET_FAIL;
  }
  if (pull_value != (uint32_t)k_ra8_esp_hosted_gpio_pull_up) {
    return RET_INVALID;
  }
  const ra8_pin_pull_t pull = (enable != 0U) ? k_ra8_pull_up : k_ra8_pull_none;
  (void)ra8_gpio_release(pin);
  return (ra8_gpio_input_init(pin, pull) == k_ra8_ok) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL
static int internal_hold_gpio(void* gpio_port, uint32_t gpio_num, uint32_t hold_value)
{
  (void)hold_value;
  ra8_port_pin_t pin = k_ra8_pin_none;
  if (!priv_ra8_esp_hosted_gpio_decode_pin(gpio_port, gpio_num, &pin)) {
    return RET_INVALID;
  }
  ra8_log_warn(s_tag, "pin hold unavailable: no per-pin retention control in ra8_hal");
  ra8_log_info_val(s_tag, "hold refused for pin", (uint32_t)pin);
  ra8_log_info_val(s_tag, "hold value requested", hold_value);
  return RET_FAIL;
}

RA8_INTERNAL
static int internal_wakeup_reason(void)
{
  ra8_reset_cause_t cause = k_ra8_reset_cause_unknown;
  if (ra8_reset_get_cause(&cause) != k_ra8_ok) {
    return (int)HOSTED_WAKEUP_UNDEFINED;
  }
  if (cause == k_ra8_reset_cause_deep_sw_standby) {
    return (int)HOSTED_WAKEUP_DEEP_SLEEP;
  }
  return (int)HOSTED_WAKEUP_NORMAL_REBOOT;
}
 
RA8_PRIV ra8_err_t priv_ra8_esp_hosted_gpio_bind(hosted_osi_funcs_t* out)
{
  RA8_CHECK_NULL_PTR(out, s_tag, "vtable must not be nullptr");
  out->_h_config_gpio                      = internal_config_gpio;
  out->_h_config_gpio_as_interrupt         = internal_config_gpio_as_interrupt;
  out->_h_teardown_gpio_interrupt          = internal_teardown_gpio_interrupt;
  out->_h_read_gpio                        = internal_read_gpio;
  out->_h_write_gpio                       = internal_write_gpio;
  out->_h_pull_gpio                        = internal_pull_gpio;
  out->_h_hold_gpio                        = internal_hold_gpio;
  out->_h_get_host_wakeup_or_reboot_reason = internal_wakeup_reason;
  return (out->_h_read_gpio != nullptr) ? k_ra8_ok : k_ra8_err_invalid_state;
}