ra8_pin_validator.c

Go to the documentation of this file.

 
#include "ra8_pin_validator.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_bit_constants.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"
#include "ra8_port_constants.h"
 
static const char* s_tag = "PINVAL";

static uint8_t s_claimed[((uint16_t)k_ra8_port_count * (uint16_t)k_ra8_pin_count) /
                         (uint16_t)k_ra8_bits_per_byte];

static const char* s_owner[(uint16_t)k_ra8_port_count * (uint16_t)k_ra8_pin_count];
 
/* Convert a packed `ra8_port_pin_t` to a flat bit index -- see implementation for details. */
RA8_INTERNAL static ra8_err_t internal_flat_index(ra8_port_pin_t pin, uint16_t* out_index)
{
  const uint8_t port = (uint8_t)RA8_PIN_PORT(pin);
  const uint8_t idx  = (uint8_t)RA8_PIN_PIN(pin);
 
  if (port >= k_ra8_port_count) {
    return k_ra8_err_gpio_invalid_port;
  }
  if (idx >= k_ra8_pin_count) {
    return k_ra8_err_gpio_invalid_pin;
  }
 
  *out_index = (uint16_t)(((uint16_t)port * (uint16_t)k_ra8_pin_count) + (uint16_t)idx);
  return k_ra8_ok;
}

ra8_err_t ra8_pin_validator_claim(ra8_port_pin_t pin, const char* owner)
{
  RA8_CHECK_NULL_PTR(owner, s_tag, "owner must not be nullptr");
 
  uint16_t        flat = 0;
  const ra8_err_t err  = internal_flat_index(pin, &flat);
  if (err != k_ra8_ok) {
    return err;
  }
 
  const uint16_t byte     = (uint16_t)(flat / k_ra8_bits_per_byte);
  const uint8_t  bit_mask = (uint8_t)(1U << (flat % k_ra8_bits_per_byte));
 
  if ((s_claimed[byte] & bit_mask) != 0U) {
    ra8_log_error(s_tag, "pin already claimed");
    return k_ra8_err_gpio_conflict;
  }
 
  s_claimed[byte] |= bit_mask;
  s_owner[flat] = owner;
  return k_ra8_ok;
}

ra8_err_t ra8_pin_validator_release(ra8_port_pin_t pin)
{
  uint16_t        flat = 0;
  const ra8_err_t err  = internal_flat_index(pin, &flat);
  if (err != k_ra8_ok) {
    return err;
  }
 
  const uint16_t byte     = (uint16_t)(flat / k_ra8_bits_per_byte);
  const uint8_t  bit_mask = (uint8_t)(1U << (flat % k_ra8_bits_per_byte));
 
  s_claimed[byte] &= (uint8_t)~bit_mask;
  s_owner[flat] = nullptr;
  return k_ra8_ok;
}

bool ra8_pin_validator_is_claimed(ra8_port_pin_t pin)
{
  uint16_t        flat = 0;
  const ra8_err_t err  = internal_flat_index(pin, &flat);
  if (err != k_ra8_ok) {
    return false;
  }
 
  const uint16_t byte     = (uint16_t)(flat / k_ra8_bits_per_byte);
  const uint8_t  bit_mask = (uint8_t)(1U << (flat % k_ra8_bits_per_byte));
  return (s_claimed[byte] & bit_mask) != 0U;
}

void ra8_pin_validator_reset(void)
{
  for (uint16_t i = 0U; i < (uint16_t)sizeof(s_claimed); i++) {
    s_claimed[i] = 0U;
  }
  for (uint16_t i = 0U; i < ((uint16_t)k_ra8_port_count * (uint16_t)k_ra8_pin_count); i++) {
    s_owner[i] = nullptr;
  }
}