ra8_nsc_comms.c

Go to the documentation of this file.

 
#include "ra8_nsc_comms.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_i3c.h"
#include "ra8_nsc_veneer.h"
#include "ra8_sci.h"
#include "ra8_spi.h"
#include "ra8_usb.h"
 
static const char* s_tag = "NSCCOM";
 
/* =============================================================================
 * SCI
 * =============================================================================
 */

RA8_NSC_VENEER ra8_err_t ra8_nsc_sci_init(uint8_t channel, const ra8_sci_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "sci_init: cfg");
  RA8_NSC_CHECK_NS_RANGE_R(cfg, sizeof(*cfg));
  return ra8_sci_init(channel, cfg);
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_sci_putc(uint8_t channel, uint8_t byte)
{
  return ra8_sci_putc_polling(channel, byte);
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_sci_getc(uint8_t channel, uint8_t* out_byte)
{
  RA8_CHECK_NULL_PTR(out_byte, s_tag, "sci_getc: out_byte");
  RA8_NSC_CHECK_NS_RANGE_RW(out_byte, sizeof(*out_byte));
  return ra8_sci_getc_polling(channel, out_byte);
}
 
/* =============================================================================
 * IIC
 * =============================================================================
 */

RA8_NSC_VENEER ra8_err_t ra8_nsc_iic_init(uint8_t channel, const ra8_i3c_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "iic_init: cfg");
  RA8_NSC_CHECK_NS_RANGE_R(cfg, sizeof(*cfg));
  /* The IIC veneer is always an I2C-compat controller; force the mode. */
  ra8_i3c_cfg_t local = *cfg;
  local.mode          = k_ra8_i3c_mode_i2c;
  return ra8_i3c_init(channel, &local);
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_iic_write(uint8_t        channel,
                                           uint8_t        target_7b,
                                           const uint8_t* data,
                                           uint32_t       len)
{
  RA8_CHECK_NULL_PTR(data, s_tag, "iic_write: data");
  RA8_NSC_CHECK_NS_RANGE_R(data, len);
  return ra8_i3c_write(channel, target_7b, data, len, false);
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_iic_read(uint8_t  channel,
                                          uint8_t  target_7b,
                                          uint8_t* out_buf,
                                          uint32_t len)
{
  RA8_CHECK_NULL_PTR(out_buf, s_tag, "iic_read: out_buf");
  RA8_NSC_CHECK_NS_RANGE_RW(out_buf, len);
  return ra8_i3c_read(channel, target_7b, out_buf, len, false);
}
 
/* =============================================================================
 * SPI
 * =============================================================================
 */

RA8_NSC_VENEER ra8_err_t ra8_nsc_spi_init(uint8_t channel, const ra8_spi_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "spi_init: cfg");
  RA8_NSC_CHECK_NS_RANGE_R(cfg, sizeof(*cfg));
  return ra8_spi_init(channel, cfg);
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_spi_xfer8(uint8_t channel, uint8_t tx, uint8_t* rx)
{
  /* rx is allowed to be NULL (the legacy ra8_spi_xfer8 contract). */
  if (rx != nullptr) {
    RA8_NSC_CHECK_NS_RANGE_RW(rx, sizeof(*rx));
  }
  return ra8_spi_xfer8(channel, tx, rx);
}

RA8_INTERNAL
static uint8_t internal_spi_unit_bytes(ra8_spi_bit_width_t bit_width)
{
  switch (bit_width) {
    case k_ra8_spi_width_8:
      return 1U;
    case k_ra8_spi_width_16:
      return 2U;
    case k_ra8_spi_width_32:
      return 4U;
    default:
      return 0U;
  }
}

RA8_INTERNAL
static bool internal_spi_byte_span(uint8_t bytes_per_unit, uint32_t len, uint32_t* out_span)
{
  const uint64_t span = (uint64_t)bytes_per_unit * (uint64_t)len;
  if (span > (uint64_t)UINT32_MAX) {
    return false;
  }
  *out_span = (uint32_t)span;
  return true;
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_spi_write(uint8_t             channel,
                                           const void*         tx,
                                           uint32_t            len,
                                           ra8_spi_bit_width_t bit_width)
{
  if (len > 0U) {
    RA8_CHECK_NULL_PTR(tx, s_tag, "spi_write: tx");
    const uint8_t bytes_per_unit = internal_spi_unit_bytes(bit_width);
    if (bytes_per_unit == 0U) {
      return k_ra8_err_invalid_arg;
    }
    uint32_t span = 0U;
    if (!internal_spi_byte_span(bytes_per_unit, len, &span)) {
      return k_ra8_err_invalid_arg;
    }
    RA8_NSC_CHECK_NS_RANGE_R(tx, span);
  }
  return ra8_spi_write(channel, tx, len, bit_width);
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_spi_read(uint8_t             channel,
                                          void*               rx,
                                          uint32_t            len,
                                          ra8_spi_bit_width_t bit_width)
{
  if (len > 0U) {
    RA8_CHECK_NULL_PTR(rx, s_tag, "spi_read: rx");
    const uint8_t bytes_per_unit = internal_spi_unit_bytes(bit_width);
    if (bytes_per_unit == 0U) {
      return k_ra8_err_invalid_arg;
    }
    uint32_t span = 0U;
    if (!internal_spi_byte_span(bytes_per_unit, len, &span)) {
      return k_ra8_err_invalid_arg;
    }
    RA8_NSC_CHECK_NS_RANGE_RW(rx, span);
  }
  return ra8_spi_read(channel, rx, len, bit_width);
}
 
RA8_NSC_VENEER ra8_err_t ra8_nsc_spi_write_read(uint32_t    ch_bw,
                                                const void* tx,
                                                void*       rx,
                                                uint32_t    len)
{
  const uint8_t             channel = (uint8_t)(ch_bw & (uint32_t)k_ra8_nsc_spi_byte_msk);
  const ra8_spi_bit_width_t bit_width =
    (ra8_spi_bit_width_t)((ch_bw >> (uint32_t)k_ra8_nsc_spi_bw_shift) &
                          (uint32_t)k_ra8_nsc_spi_byte_msk);
 
  if (len > 0U) {
    RA8_CHECK_NULL_PTR(tx, s_tag, "spi_write_read: tx");
    RA8_CHECK_NULL_PTR(rx, s_tag, "spi_write_read: rx");
    const uint8_t bytes_per_unit = internal_spi_unit_bytes(bit_width);
    if (bytes_per_unit == 0U) {
      return k_ra8_err_invalid_arg;
    }
    uint32_t span = 0U;
    if (!internal_spi_byte_span(bytes_per_unit, len, &span)) {
      return k_ra8_err_invalid_arg;
    }
    RA8_NSC_CHECK_NS_RANGE_R(tx, span);
    RA8_NSC_CHECK_NS_RANGE_RW(rx, span);
  }
  return ra8_spi_write_read(channel, tx, rx, len, bit_width);
}
 
/* =============================================================================
 * USB
 * =============================================================================
 */

RA8_NSC_VENEER ra8_err_t ra8_nsc_usb_init(ra8_usb_speed_t speed)
{
  return ra8_usb_device_init(speed);
}

RA8_NSC_VENEER ra8_err_t ra8_nsc_usb_attach(ra8_usb_speed_t speed, bool attached)
{
  return ra8_usb_device_attach(speed, attached);
}