cs.c

Go to the documentation of this file.

 
#include "icarus/icarus.h"
#include <string.h>
 
/* ============================================================================
 * INTERNAL STATE (DTCM)
 * ========================================================================= */
 
typedef struct {
    const uint8_t *addr;     
    uint32_t       size;     
    uint16_t       baseline; 
    bool           enabled;  
    bool           registered; 
} cs_entry_t;
 
DTCM_DATA_PRIV static cs_entry_t  regions[CS_MAX_REGIONS];
 
DTCM_DATA_PRIV static cs_mismatch_fn mismatch_cb;
 
DTCM_DATA_PRIV static bool cs_hw_ok;
 
#define CS_SELFTEST_EXPECTED  0x29B1u
 
/* ============================================================================
 * INTERNAL HELPERS (ITCM)
 * ========================================================================= */
 
ITCM_FUNC static bool cs_selftest(void) {
    static const uint8_t vec[] = { '1','2','3','4','5','6','7','8','9' };
    uint16_t result = crc16_ccitt(vec, 9);
    return (result == CS_SELFTEST_EXPECTED);
}
 
/* ============================================================================
 * PRIVILEGED IMPLEMENTATIONS
 * ========================================================================= */
 
ITCM_FUNC void __cs_init(void) {
    (void)memset(regions, 0, sizeof(regions));
    mismatch_cb = NULL;
    cs_hw_ok = cs_selftest();
}
 
ITCM_FUNC void __cs_set_callback(cs_mismatch_fn fn) {
    mismatch_cb = fn;
}
 
ITCM_FUNC bool __cs_add_region(uint8_t idx, const uint8_t *addr,
                                uint32_t size) {
    if ((idx >= (uint8_t)CS_MAX_REGIONS) || (addr == NULL) || (size == 0u)) {
        return false;
    }
 
    regions[idx].addr       = addr;
    regions[idx].size       = size;
    regions[idx].baseline   = crc16_ccitt(addr, (uint16_t)size);
    regions[idx].enabled    = true;
    regions[idx].registered = true;
    return true;
}
 
ITCM_FUNC bool __cs_enable(uint8_t idx, bool enabled) {
    if ((idx >= (uint8_t)CS_MAX_REGIONS) || (!regions[idx].registered)) {
        return false;
    }
    regions[idx].enabled = enabled;
    return true;
}
 
ITCM_FUNC bool __cs_rebaseline(uint8_t idx) {
    if ((idx >= (uint8_t)CS_MAX_REGIONS) || (!regions[idx].registered)) {
        return false;
    }
    regions[idx].baseline = crc16_ccitt(regions[idx].addr,
                                        (uint16_t)regions[idx].size);
    return true;
}
 
ITCM_FUNC uint8_t __cs_check_all(void) {
    /* CRC engine self-test failure — report immediately */
    if (!cs_hw_ok) {
        if (mismatch_cb != NULL) {
            mismatch_cb(0xFFu, 0u, 0u);
        }
        return 1u;
    }
 
    uint8_t failures = 0u;
    for (uint8_t i = 0u; i < (uint8_t)CS_MAX_REGIONS; i++) {
        if ((!regions[i].registered) || (!regions[i].enabled)) {
            continue;
        }
 
        uint16_t actual = crc16_ccitt(regions[i].addr,
                                       (uint16_t)regions[i].size);
        if (actual != regions[i].baseline) {
            failures++;
            if (mismatch_cb != NULL) {
                mismatch_cb(i, regions[i].baseline, actual);
            }
        }
    }
    return failures;
}
 
ITCM_FUNC bool __cs_get_region(uint8_t idx, cs_region_t *out) {
    if ((idx >= (uint8_t)CS_MAX_REGIONS) || (out == NULL)) {
        return false;
    }
    if (!regions[idx].registered) {
        return false;
    }
    out->addr     = regions[idx].addr;
    out->size     = regions[idx].size;
    out->baseline = regions[idx].baseline;
    out->enabled  = regions[idx].enabled;
    return true;
}
 
ITCM_FUNC uint8_t __cs_region_count(void) {
    uint8_t n = 0u;
    for (uint8_t i = 0u; i < (uint8_t)CS_MAX_REGIONS; i++) {
        if (regions[i].registered) {
            n++;
        }
    }
    return n;
}
 
/* Public API wrappers are in svc.c (SVC gates for unprivileged access). */