ra8_dma.c

Go to the documentation of this file.

 
#include "ra8_dma.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_dmac.h"
#include "ra8_err.h"
#include "ra8_log.h"
#include "ra8_mstp.h"
#include "ra8_mstp_regs.h"
 
static const char* s_tag = "DMA";
 
/* =============================================================================
 * State
 * =============================================================================
 */

typedef struct {
  ra8_dma_complete_fn_t on_complete; 
  void*                 ctx;         
  bool                  in_use;      
} ra8_dma_channel_state_t;

static ra8_dma_channel_state_t s_channels[k_ra8_dma_channel_count];
 
#ifdef RA8_OFF_TARGET
static ra8_dma_request_t s_fake_requests[k_ra8_dma_channel_count];
#endif

static bool s_initialized = false;
 
/* =============================================================================
 * Internal helpers
 * =============================================================================
 */

RA8_INTERNAL static uint8_t internal_find_free(void)
{
  for (uint8_t ch = 0U; ch < k_ra8_dma_channel_count; ++ch) {
    if (!s_channels[ch].in_use) {
      return ch;
    }
  }
  return k_ra8_dma_channel_none;
}

RA8_INTERNAL static void internal_pack_dmac_cfg(const ra8_dma_request_t* req,
                                                ra8_dmac_config_t*       out_cfg)
{
  out_cfg->src     = (uint32_t)req->src_addr;
  out_cfg->dst     = (uint32_t)req->dst_addr;
  out_cfg->count   = req->count;
  out_cfg->width   = req->width;
  out_cfg->src_inc = req->src_inc;
  out_cfg->dst_inc = req->dst_inc;
}

RA8_INTERNAL static ra8_err_t internal_validate_request(const ra8_dma_request_t* req)
{
  if (req->count == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if ((uint8_t)req->width > k_ra8_dmac_width_word) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * Public API
 * =============================================================================
 */

ra8_err_t ra8_dma_init(void)
{
  ra8_log_info(s_tag, "ra8_dma_init");
 
  /* HUM Ch 11.2.6 "MSTPCRA : Module Stop Control Register A", p 443
   *  -- DMAC0 + DTC0 share MSTPA22. */
  const ra8_err_t mst_err = ra8_mstp_enable(k_ra8_mstp_dmac0_dtc0);
  if (mst_err != k_ra8_ok) {
    ra8_log_error_val(s_tag, "mstp enable failed", (uint32_t)mst_err);
    return k_ra8_err_hw_init_failed;
  }
 
  for (uint8_t ch = 0U; ch < k_ra8_dma_channel_count; ++ch) {
    s_channels[ch].on_complete = nullptr;
    s_channels[ch].ctx         = nullptr;
    s_channels[ch].in_use      = false;
  }
  s_initialized = true;
  return k_ra8_ok;
}

ra8_err_t ra8_dma_deinit(void)
{
  /* Tear down every in-use channel before releasing the MSTP
   * reference so no pending transfer can wedge the DMAC block. */
  for (uint8_t ch = 0U; ch < k_ra8_dma_channel_count; ++ch) {
    if (s_channels[ch].in_use) {
      /* Ignore dmac_stop errors -- the goal is to get every
       * channel into a safe state before releasing MSTP. */
      (void)ra8_dmac_stop(ch);
      s_channels[ch].on_complete = nullptr;
      s_channels[ch].ctx         = nullptr;
      s_channels[ch].in_use      = false;
    }
  }
 
  const ra8_err_t mst_err = ra8_mstp_disable(k_ra8_mstp_dmac0_dtc0);
  if (mst_err != k_ra8_ok) {
    ra8_log_error_val(s_tag, "mstp disable failed", (uint32_t)mst_err);
    return k_ra8_err_hw_error;
  }
  s_initialized = false;
  return k_ra8_ok;
}

ra8_err_t ra8_dma_request(const ra8_dma_request_t* req, uint8_t* out_channel)
{
  RA8_CHECK_NULL_PTR(req, s_tag, "request must not be NULL");
  RA8_CHECK_NULL_PTR(out_channel, s_tag, "out_channel must not be NULL");
  if (!s_initialized) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_err_t verr = internal_validate_request(req);
  if (verr != k_ra8_ok) {
    return verr;
  }
 
  const uint8_t ch = internal_find_free();
  if (ch == k_ra8_dma_channel_none) {
    ra8_log_error(s_tag, "no free channel");
    return k_ra8_err_no_mem;
  }
 
  ra8_dmac_config_t cfg = {};
  internal_pack_dmac_cfg(req, &cfg);
 
  const ra8_err_t derr = ra8_dmac_start(ch, &cfg);
  if (derr != k_ra8_ok) {
    ra8_log_error_val(s_tag, "dmac_start failed", (uint32_t)derr);
    return k_ra8_err_hw_error;
  }
 
  s_channels[ch].on_complete = req->on_complete;
  s_channels[ch].ctx         = req->ctx;
  s_channels[ch].in_use      = true;
#ifdef RA8_OFF_TARGET
  s_fake_requests[ch] = *req;
#endif
  *out_channel = ch;
  return k_ra8_ok;
}

ra8_err_t ra8_dma_release(uint8_t channel)
{
  if (channel >= k_ra8_dma_channel_count) {
    return k_ra8_err_invalid_arg;
  }
  if (!s_channels[channel].in_use) {
    return k_ra8_err_invalid_state;
  }
 
  /* ra8_dmac_stop itself drops one MSTP reference -- the bit
   * stays cleared because ra8_dma_init holds the root reference. */
  const ra8_err_t stop_err = ra8_dmac_stop(channel);
  if (stop_err != k_ra8_ok) {
    ra8_log_error_val(s_tag, "dmac_stop failed", (uint32_t)stop_err);
    return k_ra8_err_hw_error;
  }
 
  s_channels[channel].on_complete = nullptr;
  s_channels[channel].ctx         = nullptr;
  s_channels[channel].in_use      = false;
  return k_ra8_ok;
}
 
#ifdef RA8_OFF_TARGET
const ra8_dma_request_t* ra8_dma_fake_peek_request(uint8_t channel)
{
  if (channel >= k_ra8_dma_channel_count) {
    return nullptr;
  }
  if (!s_channels[channel].in_use) {
    return nullptr;
  }
  return &s_fake_requests[channel];
}
#endif
 
ra8_err_t ra8_dma_channel_is_busy(uint8_t channel, bool* out_busy)
{
  RA8_CHECK_NULL_PTR(out_busy, s_tag, "out_busy must not be NULL");
  if (channel >= k_ra8_dma_channel_count) {
    return k_ra8_err_invalid_arg;
  }
  *out_busy = s_channels[channel].in_use;
  return k_ra8_ok;
}

RA8_ISR_SAFE
void ra8_dma_dispatch_complete(uint8_t channel)
{
  if (channel >= k_ra8_dma_channel_count) {
    return;
  }
  const ra8_dma_complete_fn_t cb  = s_channels[channel].on_complete;
  void* const                 ctx = s_channels[channel].ctx;
  if (cb != nullptr) {
    cb(ctx);
  }
}