ra8_canfd_afl.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_check.h"
#include "ra8_err.h"
 
static const char* s_tag = "CANFD";

typedef enum : uint32_t {
  k_ra8_canfd_afl_page0 = 0U, 
} ra8_canfd_afl_local_t;

RA8_INTERNAL
static ra8_err_t internal_afl_validate_rule(const ra8_canfd_afl_rule_t* rule)
{
  if (rule->target_rx >= (uint8_t)k_ra8_canfd_rx_fifo_count) {
    return k_ra8_err_invalid_arg;
  }
  if (rule->extended) {
    if ((rule->id & ~(uint32_t)k_ra8_canfd_id_ext_mask) != 0U) {
      return k_ra8_err_invalid_arg;
    }
    if ((rule->mask & ~(uint32_t)k_ra8_canfd_id_ext_mask) != 0U) {
      return k_ra8_err_invalid_arg;
    }
    return k_ra8_ok;
  }
  if ((rule->id & ~(uint32_t)k_ra8_canfd_id_std_mask) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  if ((rule->mask & ~(uint32_t)k_ra8_canfd_id_std_mask) != 0U) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static uint32_t internal_afl_id_word(const ra8_canfd_afl_rule_t* rule)
{
  const uint32_t masked = rule->extended ? (rule->id & (uint32_t)k_ra8_canfd_id_ext_mask)
                                         : (rule->id & (uint32_t)k_ra8_canfd_id_std_mask);
  uint32_t       word   = masked;
  if (rule->extended) {
    word |= (uint32_t)k_ra8_canfd_id_ide;
  }
  if (rule->rtr) {
    word |= (uint32_t)k_ra8_canfd_id_rtr;
  }
  return word;
}

RA8_INTERNAL
static uint32_t internal_afl_mask_word(const ra8_canfd_afl_rule_t* rule)
{
  const uint32_t masked = rule->extended ? (rule->mask & (uint32_t)k_ra8_canfd_id_ext_mask)
                                         : (rule->mask & (uint32_t)k_ra8_canfd_id_std_mask);
  return masked | (uint32_t)k_ra8_gaflm_bit_gaflidem | (uint32_t)k_ra8_gaflm_bit_gaflrtrm;
}

RA8_INTERNAL
static uint32_t internal_afl_p1_word(const ra8_canfd_afl_rule_t* rule)
{
  return (uint32_t)k_ra8_gaflp1_bit_gaflfdp0 << rule->target_rx;
}

RA8_INTERNAL
static void
internal_afl_write_slot(volatile r_canfd_t* reg, uint8_t slot, const ra8_canfd_afl_rule_t* rule)
{
  /* HUM Ch 41.2.19 "CFDGAFLID : Acceptance Filter List ID Register" p 2735 */
  reg->CFDGAFL[slot].ID = internal_afl_id_word(rule);
  /* HUM Ch 41.2.20 "CFDGAFLM : Acceptance Filter List ID Mask Register" p 2736 */
  reg->CFDGAFL[slot].M = internal_afl_mask_word(rule);
  /* HUM Ch 41.2.21 "CFDGAFLP0 : Acceptance Filter List Pointer 0 Register" p 2738 */
  reg->CFDGAFL[slot].P0 = 0U;
  /* HUM Ch 41.2.22 "CFDGAFLP1 : Acceptance Filter List Pointer 1 Register" p 2740 */
  reg->CFDGAFL[slot].P1 = internal_afl_p1_word(rule);
}

RA8_INTERNAL
static void internal_afl_set_rule_count(volatile r_canfd_t* reg, uint8_t count)
{
  /* HUM Ch 41.2.18 "CFDGAFLCFG0 : Global AFL Configuration Register 0" p 2735 */
  const uint32_t cfg0 = reg->CFDGAFLCFG0;
  const uint32_t rnc  = ((uint32_t)count & k_ra8_gaflcfg0_mask_rnc0) << k_ra8_gaflcfg0_shift_rnc0;
  /* HUM Ch 41.2.18 "CFDGAFLCFG0 : Global AFL Configuration Register 0" p 2735 */
  reg->CFDGAFLCFG0 = (cfg0 & ~(k_ra8_gaflcfg0_mask_rnc0 << k_ra8_gaflcfg0_shift_rnc0)) | rnc;
}

RA8_INTERNAL
static ra8_err_t internal_afl_validate_all(const ra8_canfd_afl_rule_t* rules, uint8_t count)
{
  for (uint8_t i = 0U; i < count; i++) {
    const ra8_err_t v = internal_afl_validate_rule(&rules[i]);
    if (v != k_ra8_ok) {
      return v;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t
ra8_canfd_set_accept_filter(uint8_t channel, const ra8_canfd_afl_rule_t* rules, uint8_t count)
{
  RA8_CHECK_NULL_PTR(rules, s_tag, "rules must not be nullptr");
  volatile r_canfd_t* reg = ra8_canfd(channel);
  RA8_CHECK_NULL_PTR(reg, s_tag, "channel out of range");
  if (count == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (count > (uint8_t)k_ra8_canfd_afl_rule_capacity) {
    return k_ra8_err_invalid_arg;
  }
 
  const ra8_err_t v = internal_afl_validate_all(rules, count);
  if (v != k_ra8_ok) {
    return v;
  }
 
  /* Unlock the AFL data window and select page 0 (AFLPN + AFLDAE). */
  /* HUM Ch 41.2.17 "CFDGAFLECTR : AFL Entry Control Register" p 2734 */
  reg->CFDGAFLECTR =
    ((uint32_t)k_ra8_canfd_afl_page0 & k_ra8_gaflectr_mask_aflpn) | k_ra8_gaflectr_bit_afldae;
 
  internal_afl_set_rule_count(reg, count);
 
  for (uint8_t i = 0U; i < count; i++) {
    internal_afl_write_slot(reg, i, &rules[i]);
  }
 
  /* Re-lock the AFL data window (clear AFLDAE). */
  /* HUM Ch 41.2.17 "CFDGAFLECTR : AFL Entry Control Register" p 2734 */
  reg->CFDGAFLECTR = 0U;
  return k_ra8_ok;
}