board_periph_crc.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <stdio.h>
 
#include "board_periph_block.h"
#include "emu_host_io_internal.h"

typedef enum : uint32_t {
  k_u32_all   = 0xFFFFFFFFU, 
  k_u16_mask  = 0xFFFFU,     
  k_byte_mask = 0xFFU,       
} crc_lit_t;

typedef enum : uint64_t {
  k_crc_base    = 0x40310000UL, 
  k_crc_span    = 0x20UL,       
  k_crc_off_cr0 = 0x00UL,       
  k_crc_off_cr1 = 0x01UL,       
  k_crc_off_dir = 0x04UL,       
  k_crc_off_dor = 0x08UL,       
} crc_map_t;

typedef enum : uint32_t {
  k_crc_gps_mask = 0x07U, 
  k_crc_dorclr   = 0x80U, 
} crc_cr0_field_t;

typedef enum : uint32_t {
  k_crc_gps_8     = 1U, 
  k_crc_gps_16    = 2U, 
  k_crc_gps_ccitt = 3U, 
  k_crc_gps_32    = 4U, 
  k_crc_gps_32c   = 5U, 
} crc_gps_t;

typedef enum : uint32_t {
  k_crc_poly_16_refl  = 0x0000A001U, 
  k_crc_poly_32_refl  = 0xEDB88320U, 
  k_crc_poly_32c_refl = 0x82F63B78U, 
} crc_poly_refl_t;

typedef enum : uint32_t {
  k_crc_poly_8_fwd     = 0x00000007U, 
  k_crc_poly_ccitt_fwd = 0x00001021U, 
} crc_poly_fwd_t;

typedef enum : uint32_t {
  k_crc_block_order = 140U, 
} crc_order_t;

typedef struct {
  uint8_t  cr0;   
  uint8_t  cr1;   
  uint32_t dor;   
  uint32_t bytes; 
} crc_state_t;
 
static crc_state_t s_crc;

RA8_INTERNAL static uint32_t internal_crc_step_reflected(uint32_t crc, uint8_t byte, uint32_t poly)
{
  crc ^= (uint32_t)byte;
  for (uint32_t i = 0U; i < 8U; i++) {
    crc = ((crc & 1U) != 0U) ? ((crc >> 1) ^ poly) : (crc >> 1);
  }
  return crc;
}

RA8_INTERNAL static uint32_t
internal_crc_step_forward(uint32_t crc, uint8_t byte, uint32_t poly, uint32_t width)
{
  const uint32_t top = 1U << (width - 1U);
  const uint32_t msk = (width >= 32U) ? (uint32_t)k_u32_all : ((1U << width) - 1U);
  crc ^= (uint32_t)byte << (width - 8U);
  for (uint32_t i = 0U; i < 8U; i++) {
    const bool set = (crc & top) != 0U;
    crc            = (crc << 1) & msk;
    if (set) {
      crc ^= poly;
    }
  }
  return crc & msk;
}

RA8_INTERNAL static void internal_crc_fold_byte(uint8_t byte)
{
  switch ((uint32_t)(s_crc.cr0 & (uint8_t)k_crc_gps_mask)) {
    case (uint32_t)k_crc_gps_8:
      s_crc.dor = internal_crc_step_forward(s_crc.dor, byte, (uint32_t)k_crc_poly_8_fwd, 8U);
      break;
    case (uint32_t)k_crc_gps_16:
      s_crc.dor = internal_crc_step_reflected(s_crc.dor, byte, (uint32_t)k_crc_poly_16_refl);
      break;
    case (uint32_t)k_crc_gps_ccitt:
      s_crc.dor = internal_crc_step_forward(s_crc.dor, byte, (uint32_t)k_crc_poly_ccitt_fwd, 16U);
      break;
    case (uint32_t)k_crc_gps_32:
      s_crc.dor = internal_crc_step_reflected(s_crc.dor, byte, (uint32_t)k_crc_poly_32_refl);
      break;
    case (uint32_t)k_crc_gps_32c:
      s_crc.dor = internal_crc_step_reflected(s_crc.dor, byte, (uint32_t)k_crc_poly_32c_refl);
      break;
    default:
      break; /* GPS=0: no calculation. */
  }
  s_crc.bytes++;
}

RA8_INTERNAL static void internal_crc_reset(void)
{
  s_crc.cr0   = 0U;
  s_crc.cr1   = 0U;
  s_crc.dor   = 0U;
  s_crc.bytes = 0U;
}

RA8_INTERNAL static uint64_t internal_crc_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_crc_base;
  if (off == (uint64_t)k_crc_off_cr0) {
    return s_crc.cr0;
  }
  if (off == (uint64_t)k_crc_off_cr1) {
    return s_crc.cr1;
  }
  if ((off >= (uint64_t)k_crc_off_dor) && (off < (uint64_t)k_crc_off_dor + 4UL)) {
    /* CRCDOR and its 16/8-bit aliases share +0x08; serve the low bytes. */
    const uint32_t shift = (uint32_t)(off - (uint64_t)k_crc_off_dor) * 8U;
    return (uint64_t)(s_crc.dor >> shift);
  }
  return 0U;
}

RA8_INTERNAL static void
internal_crc_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  const uint64_t off = addr - (uint64_t)k_crc_base;
  if (off == (uint64_t)k_crc_off_cr0) {
    s_crc.cr0 = (uint8_t)value;
    if (((uint8_t)value & (uint8_t)k_crc_dorclr) != 0U) {
      s_crc.dor = 0U; /* DORCLR clears the running remainder. */
    }
    return;
  }
  if (off == (uint64_t)k_crc_off_cr1) {
    s_crc.cr1 = (uint8_t)value;
    return;
  }
  if (off == (uint64_t)k_crc_off_dir) {
    /* Fold each byte of the access LSB-first: a 32-bit word feed (CRC-32/32C)
     * delivers four bytes in the order ra8_crc's word packing produces, an
     * 8-bit feed (CRC-8/16/CCITT) delivers one. */
    unsigned n = size;
    if (size > 4U) {
      n = 4U;
    } else if (size == 0U) {
      n = 1U;
    }
    for (unsigned i = 0U; i < n; i++) {
      internal_crc_fold_byte((uint8_t)((value >> (8U * i)) & (uint32_t)k_byte_mask));
    }
    return;
  }
  if ((off >= (uint64_t)k_crc_off_dor) && (off < (uint64_t)k_crc_off_dor + 4UL)) {
    /* Seed / overwrite CRCDOR (driver pre-seeds 0xFFFFFFFF for CRC-32/32C). */
    if (size >= 4U) {
      s_crc.dor = (uint32_t)value;
    } else {
      const uint32_t shift = (uint32_t)(off - (uint64_t)k_crc_off_dor) * 8U;
      const uint32_t mask  = ((size == 2U) ? (uint32_t)k_u16_mask : (uint32_t)k_byte_mask) << shift;
      s_crc.dor            = (s_crc.dor & ~mask) | (((uint32_t)value << shift) & mask);
    }
  }
}

RA8_INTERNAL static void internal_crc_report(void)
{
  if (s_crc.bytes == 0U) {
    return; /* Untouched: stay quiet. */
  }
  (void)priv_emu_io_errf("  CRC           : GPS=%u CRCDOR=0x%08X bytes=%u\n",
                         (unsigned)(s_crc.cr0 & (uint8_t)k_crc_gps_mask),
                         s_crc.dor,
                         s_crc.bytes);
}

static const board_periph_block_t s_k_crc_block = {
  .base   = (uint32_t)k_crc_base,
  .span   = (uint32_t)k_crc_span,
  .order  = (uint32_t)k_crc_block_order,
  .read   = internal_crc_read,
  .write  = internal_crc_write,
  .tick   = nullptr,
  .reset  = internal_crc_reset,
  .report = internal_crc_report,
  .name   = "CRC",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_crc_block_register(void)
{
  board_periph_register_block(&s_k_crc_block);
}