adc_selfdiag.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "adc_internal.h"
#include "ra8_adc.h"
#include "ra8_adc_b_regs.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"
 
static const char* s_tag = "ADC";
 
/* The public ra8_adc_internal_chan_t values must mirror the register-header
 * CNVCS codes so ra8_adc_b_adexdr_index_for_chan() maps them correctly. */
static_assert((uint8_t)k_ra8_adc_chan_temperature == (uint8_t)k_ra8_adc_b_chan_temperature,
              "temperature CNVCS code drift between ra8_adc.h and ra8_adc_b_regs.h");
static_assert((uint8_t)k_ra8_adc_chan_int_ref_volt == (uint8_t)k_ra8_adc_b_chan_int_ref_volt,
              "internal-Vref CNVCS code drift between ra8_adc.h and ra8_adc_b_regs.h");

typedef enum : uint8_t {
  k_ra8_adc_diag_vchan = 23U, 
  k_ra8_adc_diag_group = 8U,  
} ra8_adc_diag_slot_t;

typedef enum : int32_t {
  k_ra8_adc_selfdiag_expect_mode1 = 0,      
  k_ra8_adc_selfdiag_expect_mode2 = -32768, 
  k_ra8_adc_selfdiag_expect_mode3 = 32767,  
} ra8_adc_selfdiag_expect_t;

typedef enum : int32_t {
  k_ra8_adc_selfdiag_tol_lsb = 256, 
} ra8_adc_selfdiag_tol_t;

RA8_INTERNAL static bool internal_diagval_for_mode(ra8_adc_selfdiag_mode_t mode,
                                                   uint32_t*               out_diagval)
{
  switch (mode) {
    case k_ra8_adc_selfdiag_mode_1:
      *out_diagval = (uint32_t)k_ra8_adsgdcr_diag_mode1;
      return true;
    case k_ra8_adc_selfdiag_mode_2:
      *out_diagval = (uint32_t)k_ra8_adsgdcr_diag_mode2;
      return true;
    case k_ra8_adc_selfdiag_mode_3:
      *out_diagval = (uint32_t)k_ra8_adsgdcr_diag_mode3;
      return true;
    default:
      return false;
  }
}

RA8_INTERNAL static int32_t internal_selfdiag_expected(ra8_adc_selfdiag_mode_t mode)
{
  switch (mode) {
    case k_ra8_adc_selfdiag_mode_2:
      return (int32_t)k_ra8_adc_selfdiag_expect_mode2;
    case k_ra8_adc_selfdiag_mode_3:
      return (int32_t)k_ra8_adc_selfdiag_expect_mode3;
    case k_ra8_adc_selfdiag_mode_1:
    default:
      return (int32_t)k_ra8_adc_selfdiag_expect_mode1;
  }
}

RA8_INTERNAL static bool internal_selfdiag_in_band(int32_t diff)
{
  return (diff <= (int32_t)k_ra8_adc_selfdiag_tol_lsb) &&
         (diff >= -(int32_t)k_ra8_adc_selfdiag_tol_lsb);
}

RA8_INTERNAL static bool internal_is_supported_ext_chan(ra8_adc_internal_chan_t chan)
{
  return (chan == k_ra8_adc_chan_temperature) || (chan == k_ra8_adc_chan_int_ref_volt);
}

RA8_INTERNAL static void
internal_program_ext_channel(uint8_t vch, uint8_t physical_ch, uint8_t group, bool differential)
{
  volatile uint32_t* reg = ra8_adc_b_adchcr(vch);
  if (reg == nullptr) {
    return;
  }
  const uint32_t cnvcs =
    ((uint32_t)physical_ch << (uint32_t)k_ra8_adchcr_bit_cnvcs) & k_ra8_adchcr_mask_cnvcs;
  const uint32_t sgsel =
    ((uint32_t)group << (uint32_t)k_ra8_adchcr_bit_sgsel) & k_ra8_adchcr_mask_sgsel;
  const uint32_t ainmd =
    differential ? (((uint32_t)1UL << (uint32_t)k_ra8_adchcr_bit_ainmd) & k_ra8_adchcr_mask_ainmd)
                 : 0UL;
  /* HUM Ch 53.2.3.1 "ADCHCRn : A/D Conversion Channel Configuration Register n" p 3335 */
  *reg = (cnvcs | sgsel | ainmd);
}

RA8_INTERNAL static void internal_set_data_format(uint8_t vch, uint8_t adprc, uint8_t signsel)
{
  volatile uint32_t* reg = ra8_adc_b_addopcrc(vch);
  if (reg == nullptr) {
    return;
  }
  const uint32_t adprc_field =
    ((uint32_t)adprc << (uint32_t)k_ra8_addopcrc_bit_adprc) & k_ra8_addopcrc_mask_adprc;
  const uint32_t sign_field =
    ((uint32_t)signsel << (uint32_t)k_ra8_addopcrc_bit_signsel) & k_ra8_addopcrc_mask_signsel;
  /* HUM Ch 53.2.3.4 "ADDOPCRCn : A/D Conversion Data Operation Control C Register n" p 3339 */
  const uint32_t cleared = *reg & ~(k_ra8_addopcrc_mask_adprc | k_ra8_addopcrc_mask_signsel);
  *reg                   = (cleared | adprc_field | sign_field);
}

RA8_INTERNAL static ra8_err_t internal_start_and_wait(uint8_t group)
{
  volatile uint32_t* adstr = ra8_adc_b_adstr(group);
  if (adstr == nullptr) {
    return k_ra8_err_out_of_range;
  }
  /* HUM Ch 53 "16-bit A/D Converter (ADC16H)" p 3308 */
  *adstr = k_ra8_adstr_mask_adst;
  /* HUM Ch 53 "16-bit A/D Converter (ADC16H)" p 3308 */
  for (uint32_t i = 0U; i < k_ra8_adc_busy_wait_limit; ++i) {
    if ((*ra8_adc_b_adsr() & k_ra8_adsr_mask_adact0) == 0U) {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_hw_timeout;
}

RA8_INTERNAL static ra8_err_t internal_selfdiag_run(uint32_t diagval)
{
  internal_program_ext_channel((uint8_t)k_ra8_adc_diag_vchan,
                               (uint8_t)k_ra8_adc_b_chan_selfdiag_adc0,
                               (uint8_t)k_ra8_adc_diag_group,
                               true);
  internal_set_data_format((uint8_t)k_ra8_adc_diag_vchan,
                           (uint8_t)k_ra8_addopcrc_adprc_16bit,
                           (uint8_t)k_ra8_addopcrc_signsel_signed);
 
  /* HUM Ch 53 "16-bit A/D Converter (ADC16H)" p 3308 */
  *ra8_adc_b_adsger() |= (uint32_t)(1UL << (uint32_t)k_ra8_adc_diag_group);
 
  /* HUM Ch 53.2.4.1 "ADSGDCRn : Scan Group Diagnosis Function Control Register n" p 3340 */
  volatile uint32_t* sgdcr = ra8_adc_b_adsgdcr((uint8_t)k_ra8_adc_diag_group);
  *sgdcr = (*sgdcr & ~k_ra8_adsgdcr_mask_diagval) |
           ((diagval << (uint32_t)k_ra8_adsgdcr_bit_diagval) & k_ra8_adsgdcr_mask_diagval);
 
  const ra8_err_t run_err = internal_start_and_wait((uint8_t)k_ra8_adc_diag_group);
 
  /* Always return DIAGVAL to off so later normal scans on this group are
   * not stuck in diagnosis mode (HUM Ch 53.2.4.1 p 3340). */
  /* HUM Ch 53.2.4.1 "ADSGDCRn : Scan Group Diagnosis Function Control Register n" p 3340 */
  *sgdcr = *sgdcr & ~k_ra8_adsgdcr_mask_diagval;
 
  return run_err;
}
 
ra8_err_t ra8_adc_self_diagnose(ra8_adc_selfdiag_mode_t mode, uint16_t* out_code, bool* out_pass)
{
  RA8_CHECK_NULL_PTR(out_code, s_tag, "out_code must not be nullptr");
  RA8_CHECK_NULL_PTR(out_pass, s_tag, "out_pass must not be nullptr");
  *out_code = 0U;
  *out_pass = false;
 
  uint32_t diagval = 0U;
  if (!internal_diagval_for_mode(mode, &diagval)) {
    return k_ra8_err_invalid_arg;
  }
 
  const ra8_err_t run_err = internal_selfdiag_run(diagval);
  RA8_RETURN_ON_ERROR(run_err, s_tag, "self_diagnose: conversion");
 
  /* HUM Ch 53.2.13.2 "ADEXDRn : A/D Extended Analog Data Register n" p 3391 */
  const uint32_t exd =
    *ra8_adc_b_adexdr((uint8_t)k_ra8_adc_b_chan_selfdiag_adc0 - (uint8_t)k_ra8_adc_b_ext_chan_base);
  const uint16_t data     = (uint16_t)(exd & k_ra8_adexdr_mask_data);
  const bool     err_flag = (exd & k_ra8_adexdr_mask_err) != 0U;
 
  const int32_t actual   = (int32_t)(int16_t)data; /* signed format (SIGNSEL=0). */
  const int32_t expected = internal_selfdiag_expected(mode);
  const bool    in_band  = internal_selfdiag_in_band(actual - expected);
 
  *out_code = data;
  *out_pass = (!err_flag) && in_band;
  return k_ra8_ok;
}
 
ra8_err_t ra8_adc_read_internal_channel(ra8_adc_internal_chan_t chan, uint16_t* out_raw)
{
  RA8_CHECK_NULL_PTR(out_raw, s_tag, "out_raw must not be nullptr");
  *out_raw = 0U;
  if (!internal_is_supported_ext_chan(chan)) {
    return k_ra8_err_invalid_arg;
  }
 
  /* Single-ended, 12-bit unsigned so the code lines up with the 12-bit
   * scale used by the TSN two-point calibration (HUM Ch 55.2.2 p 3498). */
  internal_program_ext_channel((uint8_t)k_ra8_adc_diag_vchan,
                               (uint8_t)chan,
                               (uint8_t)k_ra8_adc_diag_group,
                               false);
  internal_set_data_format((uint8_t)k_ra8_adc_diag_vchan,
                           (uint8_t)k_ra8_addopcrc_adprc_12bit,
                           (uint8_t)k_ra8_addopcrc_signsel_unsigned);
 
  /* HUM Ch 53 "16-bit A/D Converter (ADC16H)" p 3308 */
  *ra8_adc_b_adsger() |= (uint32_t)(1UL << (uint32_t)k_ra8_adc_diag_group);
 
  const ra8_err_t run_err = internal_start_and_wait((uint8_t)k_ra8_adc_diag_group);
  /* GCOVR_EXCL_BR_START -- HW convert timing */
  RA8_RETURN_ON_ERROR(run_err, s_tag, "read_internal: conversion");
  /* GCOVR_EXCL_BR_STOP */
 
  const uint8_t            idx = ra8_adc_b_adexdr_index_for_chan((uint8_t)chan);
  volatile const uint32_t* exd = ra8_adc_b_adexdr(idx);
  if (exd == nullptr) {
    return k_ra8_err_out_of_range;
  }
  /* HUM Ch 53.2.13.2 "ADEXDRn : A/D Extended Analog Data Register n" p 3391 */
  *out_raw = (uint16_t)(*exd & k_ra8_adexdr_mask_data);
  return k_ra8_ok;
}