---

/*--------------------------------------------------------------------------*/
/* Return LM status                                                         */
/*--------------------------------------------------------------------------*/
int32_t LM_SystemLmStatus(uint32_t lmId, uint32_t stateLm, uint32_t *state,
    int32_t *errStatus)
{
    int32_t status = SM_ERR_SUCCESS;

    /* Check LM */
    if (stateLm >= SM_NUM_LM)
    {
        status = SM_ERR_NOT_FOUND;
    }
    else
    {
        /* Return info */
        *state = (uint32_t) s_lmState[stateLm];
        *errStatus = s_lmError[stateLm];
    }

    // cppcheck-suppress unknownMacro
    SM_TEST_MODE_EXEC(SM_TEST_MODE_LMM_ALT1, *errStatus = SM_ERR_TEST)
    SM_TEST_MODE_ERR(SM_TEST_MODE_LMM_LVL1, SM_ERR_TEST)

    /* Return status */
    return status;
}

/*--------------------------------------------------------------------------*/
/* Check if an LM can be booted                                             */
/*--------------------------------------------------------------------------*/
int32_t LMM_SystemLmCheck(uint32_t bootLm)
{
    int32_t status = SM_ERR_SUCCESS;
    uint32_t idx = g_lmmConfig[bootLm].start - 1U;

    /* Loop over start list */
    while (idx < SM_LM_NUM_START)
    {
        const lmm_startstop_t *ptr = &s_lmmStart[idx];

        /* End for this LM */
        if (ptr->lmId != bootLm)
        {
            break;
        }

        /* CPU command for this mSel? */
        if ((ptr->mSel == s_modeSel) && (ptr->ss == LMM_SS_CPU))
        {
            /* Check vector */
            status = LMM_CpuBootCheck(ptr->lmId, ptr->rsrc);

            /* Translate and exit */
            if (status != SM_ERR_SUCCESS)
            {
                status = SM_ERR_MISSING_PARAMETERS;
                break;
            }
        }

        /* Next entry */
        idx++;
    }

    SM_TEST_MODE_ERR(SM_TEST_MODE_LMM_LVL1, SM_ERR_TEST)

    /* Return status */
    return status;
}

/*--------------------------------------------------------------------------*/
/* Check if a CPU is started when an LM boots                               */
/*--------------------------------------------------------------------------*/
bool LM_CpuCheck(uint32_t lmId, uint32_t cpuId)
{
    bool rtn = false;
    uint32_t idx = g_lmmConfig[lmId].start - 1U;

    /* Loop over start list to check for CPU */
    while ((!rtn) && (idx < SM_LM_NUM_START))
    {
        const lmm_startstop_t *ptr = &s_lmmStart[idx];

        /* End for this LM? */
        if (ptr->lmId != lmId)
        {
            break;
        }

        /* For this mode? */
        if (ptr->mSel == s_modeSel)
        {
            /* Process start command */
            if ((ptr->ss == LMM_SS_CPU) && (ptr->rsrc == cpuId))
            {
                rtn = true;
            }
        }

        /* Next entry */
        idx++;
    }

    /* Return state */
    return rtn;
}

/*--------------------------------------------------------------------------*/
/* Power on LM                                                              */
/*--------------------------------------------------------------------------*/
int32_t LMM_SystemLmPowerOn(uint32_t lmId, uint32_t agentId, uint32_t pwrLm)
{
    int32_t status = SM_ERR_SUCCESS;

    if (s_lmState[pwrLm] == LMM_STATE_LM_OFF)
    {
        /* Start resources minus CPU starts */
        if (g_lmmConfig[pwrLm].start != 0U)
        {
            status = LM_ProcessStart(pwrLm,
                g_lmmConfig[pwrLm].start - 1U, false);
        }

        if (status == SM_ERR_SUCCESS)
        {
            /* Record state */
            s_lmState[pwrLm] = LMM_STATE_LM_POWERED;
        }

        /* Record status */
        s_lmError[pwrLm] = status;
    }

    SM_TEST_MODE_ERR(SM_TEST_MODE_LMM_LVL1, SM_ERR_TEST)

    /* Return status */
    return status;
}

/*--------------------------------------------------------------------------*/
/* Boot LM                                                                  */
/*--------------------------------------------------------------------------*/
int32_t LMM_SystemLmBoot(uint32_t lmId, uint32_t agentId, uint32_t bootLm,
    const lmm_rst_rec_t *bootRec)
{
    int32_t status;
    lmm_rpc_trigger_t trigger =
    {
        .event = LMM_TRIGGER_SYSTEM,
        .parm[0] = LMM_TRIGGER_PARM_LM_BOOT,
        .parm[1] = agentId,
        .parm[2] = bootLm,
        .parm[3] = lmId
    };

    /* Check LM */
    status = LMM_SystemLmCheck(bootLm);

    /* Boot LM */
    if (status == SM_ERR_SUCCESS)
    {
        status = LMM_DoBoot(&trigger, bootRec);
    }
    else
    {
        s_lmError[bootLm] = status;
    }

    SM_TEST_MODE_ERR(SM_TEST_MODE_LMM_LVL1, SM_ERR_TEST)

    /* Return status */
    return status;
}