ra8_canfd_timing.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_canfd.h"
#include "ra8_canfd_regs.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_hal_internal.h"
#include "ra8_log.h"
 
static const char* s_tag = "CANFD";

typedef enum : uint32_t {
  k_ra8_canfd_tq_search_lo = 8U,  
  k_ra8_canfd_tq_search_hi = 25U, 
} ra8_canfd_timing_search_t;

typedef struct {
  uint32_t prescaler; 
  uint32_t tseg1;     
  uint32_t tseg2;     
  uint32_t sjw;       
} ra8_canfd_timing_t;

RA8_INTERNAL
static ra8_err_t internal_solve_timing(uint32_t            clock_hz,
                                       uint32_t            bitrate_bps,
                                       uint32_t            prescaler_max,
                                       ra8_canfd_timing_t* out)
{
  /* mcdc-deactivated: both args are validated by ra8_canfd_init upstream; defensive duplicate. */
  if ((bitrate_bps == 0U) || (clock_hz == 0U)) {
    return k_ra8_err_invalid_arg;
  }
  for (uint32_t tq = k_ra8_canfd_tq_search_hi; tq >= k_ra8_canfd_tq_search_lo; tq--) {
    const uint32_t denom = bitrate_bps * tq;
    if ((clock_hz % denom) != 0U) {
      continue;
    }
    const uint32_t prescaler = clock_hz / denom;
    if (prescaler > prescaler_max) {
      continue;
    }
    /* 75% sample point: TSEG1 = 3*(tq-1)/4, TSEG2 = tq - 1 - TSEG1. */
    const uint32_t tseg1 = ((tq - 1U) * 3U) / 4U;
    const uint32_t tseg2 = (tq - 1U) - tseg1;
    const uint32_t sjw   = (tseg2 < k_ra8_canfd_sjw_max) ? tseg2 : k_ra8_canfd_sjw_max;
    out->prescaler       = prescaler;
    out->tseg1           = tseg1;
    out->tseg2           = tseg2;
    out->sjw             = sjw;
    return k_ra8_ok;
  }
  return k_ra8_err_invalid_arg;
}

RA8_INTERNAL
static uint32_t internal_pack_ncfg(const ra8_canfd_timing_t* t)
{
  const uint32_t brp_field   = ((t->prescaler - 1U) & k_ra8_cncfg_mask_nbrp)
                               << (uint32_t)k_ra8_cncfg_shift_nbrp;
  const uint32_t tseg1_field = (t->tseg1 & k_ra8_cncfg_mask_ntseg1)
                               << (uint32_t)k_ra8_cncfg_shift_ntseg1;
  const uint32_t tseg2_field = (t->tseg2 & k_ra8_cncfg_mask_ntseg2)
                               << (uint32_t)k_ra8_cncfg_shift_ntseg2;
  const uint32_t sjw_field   = ((t->sjw - 1U) & k_ra8_cncfg_mask_nsjw)
                               << (uint32_t)k_ra8_cncfg_shift_nsjw;
  return brp_field | tseg1_field | tseg2_field | sjw_field;
}

RA8_INTERNAL
static uint32_t internal_pack_dcfg(const ra8_canfd_timing_t* t)
{
  const uint32_t brp_field   = ((t->prescaler - 1U) & k_ra8_dcfg_mask_dbrp)
                               << (uint32_t)k_ra8_dcfg_shift_dbrp;
  const uint32_t tseg1_field = (t->tseg1 & k_ra8_dcfg_mask_dtseg1)
                               << (uint32_t)k_ra8_dcfg_shift_dtseg1;
  const uint32_t tseg2_field = (t->tseg2 & k_ra8_dcfg_mask_dtseg2)
                               << (uint32_t)k_ra8_dcfg_shift_dtseg2;
  const uint32_t sjw_field   = ((t->sjw - 1U) & k_ra8_dcfg_mask_dsjw)
                               << (uint32_t)k_ra8_dcfg_shift_dsjw;
  return brp_field | tseg1_field | tseg2_field | sjw_field;
}
 
ra8_err_t ra8_canfd_set_bitrate(uint8_t channel, uint32_t bitrate_bps, uint32_t data_bitrate_bps)
{
  volatile r_canfd_t* reg = ra8_canfd(channel);
  RA8_CHECK_NULL_PTR(reg, s_tag, "channel out of range");
 
  uint32_t        pclka_hz = 0U;
  const ra8_err_t clk_err  = ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz);
  if (clk_err != k_ra8_ok) {
    return clk_err;
  }
 
  /* Nominal phase: 10-bit prescaler ceiling = 1024. */
  ra8_canfd_timing_t nominal = {};
  const ra8_err_t    n_err =
    internal_solve_timing(pclka_hz, bitrate_bps, k_ra8_canfd_prescaler_max, &nominal);
  if (n_err != k_ra8_ok) {
    return n_err;
  }
 
  /* NCFG / DCFG are only writable in CH_RESET or CH_HALT.  Use
   * CH_RESET: halt is a graceful transition that waits for any
   * in-flight TX to finish, and on internal-loopback bring-up the
   * channel may be stuck trying to TX onto a bus with no
   * acknowledger -- halt never converges. CH_RESET is the
   * immediate abort path, which is what FSP r_canfd does too.
   * HUM Ch 41 "CFDCnNCFG.NTSEG2" p 2706 */
  const ra8_err_t halt_err = priv_ra8_canfd_internal_set_channel_mode(reg, k_ra8_chmdc_reset);
  if (halt_err != k_ra8_ok) {
    return halt_err;
  }
 
  /* HUM Ch 41 "CFDCnNCFG" p 2705 */
  reg->CFDC[0].NCFG = internal_pack_ncfg(&nominal);
 
  if ((data_bitrate_bps != 0U) && (data_bitrate_bps > bitrate_bps)) {
    /* Data phase: 8-bit prescaler ceiling = 256. */
    ra8_canfd_timing_t data = {};
    const ra8_err_t    d_err =
      internal_solve_timing(pclka_hz, data_bitrate_bps, k_ra8_canfd_data_prescaler_max, &data);
    if (d_err != k_ra8_ok) {
      /* Best-effort: return the channel to CH_OPERATION so the
       * caller does not observe a half-applied edit. */
      (void)priv_ra8_canfd_internal_set_channel_mode(reg, k_ra8_chmdc_operation);
      return d_err;
    }
    /* HUM Ch 41 "CFDCnDCFG" p 2785 */
    reg->CFDC2[0].DCFG = internal_pack_dcfg(&data);
  }
 
  const ra8_err_t op_err = priv_ra8_canfd_internal_set_channel_mode(reg, k_ra8_chmdc_operation);
  if (op_err != k_ra8_ok) {
    return op_err;
  }
 
  ra8_log_info_val(s_tag, "set_bitrate bps", bitrate_bps);
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_program_data_phase(volatile r_canfd_t* reg, uint32_t data_bitrate)
{
  if (data_bitrate == 0U) {
    return k_ra8_err_invalid_arg;
  }
  uint32_t        pclka_hz = 0U;
  const ra8_err_t clk_err  = ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz);
  if (clk_err != k_ra8_ok) {
    return clk_err;
  }
  ra8_canfd_timing_t data = {};
  const ra8_err_t    err =
    internal_solve_timing(pclka_hz, data_bitrate, k_ra8_canfd_data_prescaler_max, &data);
  if (err != k_ra8_ok) {
    return err;
  }
  /* HUM Ch 41 "CFDCnDCFG" p 2785 */ /* "CFDCnDCFG" */
  reg->CFDC2[0].DCFG = internal_pack_dcfg(&data);
  return k_ra8_ok;
}
 
ra8_err_t ra8_canfd_set_brs(uint8_t channel, uint32_t fast_bitrate)
{
  volatile r_canfd_t* reg = ra8_canfd(channel);
  RA8_CHECK_NULL_PTR(reg, s_tag, "channel out of range");
  return internal_program_data_phase(reg, fast_bitrate);
}