ab_gp_ga_hooks.c

Go to the documentation of this file.

#include "ab_gp_ga_hooks.h"
 
#include "rte/utils/buffer/rte_buffer.h"
#include "rte/utils/lifecycle/rte_lifecycle.h"
#include "rte/utils/notify/rte_notify.h"
#include "rte/oal/memory/rte_mem_util.h"
 
#include "rbc_wire_types.h" /* rbc_envelope_t, RBC_MSG_CTC_ALARM, rbc_alarm_severity_t */

RTE_DECLARE_CALLBACK_LIST(ab_gp_il_envelope_handler_list_t, ab_gp_il_envelope_handler_fn, 1U);
static ab_gp_il_envelope_handler_list_t g_il_envelope_handler;
 
rte_status_t ab_gp_register_il_envelope_handler(ab_gp_il_envelope_handler_fn fn, const void *context)
{
    rte_status_t lifecycle_status;
 
    if (fn == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    lifecycle_status = rte_lifecycle_check_setup_allowed();
    if (lifecycle_status != RTE_STATUS_OK)
    {
        return lifecycle_status;
    }
    if (g_il_envelope_handler.count >= 1U)
    {
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
    g_il_envelope_handler.slots[0].fn = fn;
    g_il_envelope_handler.slots[0].context = (void *)context; /* see
        AB/GP/ma_logic/ab_gp_logic.c's own identical cast for why this is safe */
    g_il_envelope_handler.count = 1U;
    return RTE_STATUS_OK;
}
 
bool ab_gp_dispatch_il_envelope(ab_gp_train_session_t *sessions, ab_gp_db_t *db,
                                 const uint8_t env_bytes[RBC_ENVELOPE_WIRE_SIZE], uint32_t cycle,
                                 rte_example_site_t site, const char *role_tag)
{
    if ((g_il_envelope_handler.count == 0U) || (g_il_envelope_handler.slots[0].fn == NULL))
    {
        return false;
    }
    return g_il_envelope_handler.slots[0].fn(g_il_envelope_handler.slots[0].context, sessions, db, env_bytes, cycle,
                                              site, role_tag);
}


RTE_DECLARE_CALLBACK_LIST(ab_gp_il_output_producer_list_t, ab_gp_il_output_producer_fn, 1U);
static ab_gp_il_output_producer_list_t g_il_output_producer;
/* Plain static, not part of the macro-generated slot struct above (that
 * struct's own shape is fixed to one function-pointer type) - see
 * ab_gp_il_output_confirm_fn's own doc, ga_interface.h, for why this
 * exists and must only be invoked once a build's outputs are confirmed
 * forwarded. */
static ab_gp_il_output_confirm_fn g_il_output_confirm_fn = NULL;
 
rte_status_t ab_gp_register_il_output_producer(ab_gp_il_output_producer_fn fn, ab_gp_il_output_confirm_fn confirm_fn,
                                                 const void *context)
{
    rte_status_t lifecycle_status;
 
    if (fn == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    lifecycle_status = rte_lifecycle_check_setup_allowed();
    if (lifecycle_status != RTE_STATUS_OK)
    {
        return lifecycle_status;
    }
    if (g_il_output_producer.count >= 1U)
    {
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
    g_il_output_producer.slots[0].fn = fn;
    g_il_output_producer.slots[0].context = (void *)context;
    g_il_output_producer.count = 1U;
    g_il_output_confirm_fn = confirm_fn;
    return RTE_STATUS_OK;
}
 
uint8_t ab_gp_drain_il_outputs(ab_gp_il_pending_output_t out[AB_GP_IL_MAX_PENDING_OUTPUTS])
{
    if ((g_il_output_producer.count == 0U) || (g_il_output_producer.slots[0].fn == NULL))
    {
        return 0U;
    }
    return g_il_output_producer.slots[0].fn(g_il_output_producer.slots[0].context, out);
}
 
void ab_gp_confirm_il_outputs_sent(void)
{
    if ((g_il_output_producer.count != 0U) && (g_il_output_confirm_fn != NULL))
    {
        g_il_output_confirm_fn(g_il_output_producer.slots[0].context);
    }
}


RTE_DECLARE_CALLBACK_LIST(ab_gp_ctc_output_producer_list_t, ab_gp_ctc_output_producer_fn, 1U);
static ab_gp_ctc_output_producer_list_t g_ctc_output_producer;
/* Same reasoning as g_il_output_confirm_fn above. */
static ab_gp_ctc_output_confirm_fn g_ctc_output_confirm_fn = NULL;
 
rte_status_t ab_gp_register_ctc_output_producer(ab_gp_ctc_output_producer_fn fn,
                                                  ab_gp_ctc_output_confirm_fn confirm_fn, const void *context)
{
    rte_status_t lifecycle_status;
 
    if (fn == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    lifecycle_status = rte_lifecycle_check_setup_allowed();
    if (lifecycle_status != RTE_STATUS_OK)
    {
        return lifecycle_status;
    }
    if (g_ctc_output_producer.count >= 1U)
    {
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
    g_ctc_output_producer.slots[0].fn = fn;
    g_ctc_output_producer.slots[0].context = (void *)context;
    g_ctc_output_producer.count = 1U;
    g_ctc_output_confirm_fn = confirm_fn;
    return RTE_STATUS_OK;
}
 
uint8_t ab_gp_drain_ctc_outputs(ab_gp_ctc_pending_output_t out[AB_GP_CTC_MAX_PENDING_OUTPUTS])
{
    if ((g_ctc_output_producer.count == 0U) || (g_ctc_output_producer.slots[0].fn == NULL))
    {
        return 0U;
    }
    return g_ctc_output_producer.slots[0].fn(g_ctc_output_producer.slots[0].context, out);
}
 
void ab_gp_confirm_ctc_outputs_sent(void)
{
    if ((g_ctc_output_producer.count != 0U) && (g_ctc_output_confirm_fn != NULL))
    {
        g_ctc_output_confirm_fn(g_ctc_output_producer.slots[0].context);
    }
}


#define AB_GP_CTC_ALARM_WIRE_HEADER_SIZE 12U
#define AB_GP_CTC_ALARM_WIRE_L_MESSAGE 36U /* header(12) + base content(24), matching every non-TRAIN_INFO
                                             * CTC_* kind's own l_message - see ab_ga_ctc.c's own
                                             * CTC_WIRE_HEADER_SIZE/CTC_WIRE_CONTENT_SIZE_BASE. */
 
void ab_gp_build_ctc_alarm(uint8_t out[RBC_ENVELOPE_WIRE_SIZE], rbc_alarm_severity_t severity, uint32_t code,
                            uint32_t cycle, uint32_t timestamp_ms)
{
    rte_buffer_t buf;
 
    rte_mem_set(out, 0, RBC_ENVELOPE_WIRE_SIZE);
    (void)rte_buffer_init(&buf, out, RBC_ENVELOPE_WIRE_SIZE);
    out[0] = (uint8_t)RBC_MSG_CTC_ALARM;
    out[1] = 0U; /* no train_id - an alarm is channel/site-level, not about one train */
    out[2] = 0U; /* no real Subset-026 nid_message for any CTC_* kind */
    out[3] = 0U; /* reserved */
    (void)rte_buffer_set_length(&buf, 4U);
    (void)rte_buffer_write_u16_le(&buf, (uint16_t)AB_GP_CTC_ALARM_WIRE_L_MESSAGE); /* offset 4-5 */
    (void)rte_buffer_write_u16_le(&buf, 0U);                                       /* offset 6-7, reserved */
    (void)rte_buffer_write_u32_le(&buf, timestamp_ms);                             /* offset 8-11 */
    (void)rte_buffer_write_u32_le(&buf, cycle);                                    /* offset 12-15 */
    (void)rte_buffer_write_u32_le(&buf, 0U);                                       /* offset 16-19, d_lrbg - N/A */
    (void)rte_buffer_write_u32_le(&buf, (uint32_t)severity);                       /* offset 20-23 */
    (void)rte_buffer_write_u32_le(&buf, 0U);                                       /* offset 24-27, N/A */
    (void)rte_buffer_write_u32_le(&buf, code);                                     /* offset 28-31 */
    (void)rte_buffer_write_u32_le(&buf, 0U);                                       /* offset 32-35, N/A */
}