---

ims system manager:

int32_t RPC_SCMI_LmmDispatchCommand(scmi_caller_t *caller, uint32_t messageId)
{
    int32_t status = SM_ERR_SUCCESS;
    const scmi_msg_t *in = caller->msgCopy;
    scmi_msg_status_t *out = caller->msg;
    uint32_t lenOut = sizeof(scmi_msg_status_t);

    /* Handle standard messages */
    switch (messageId)
    {
        case COMMAND_PROTOCOL_VERSION:
            lenOut = sizeof(msg_tlmm0_t);
            status = LmmProtocolVersion(caller, (const scmi_msg_header_t*) in,
                (msg_tlmm0_t*) out);
            break;
        case COMMAND_PROTOCOL_ATTRIBUTES:
            lenOut = sizeof(msg_tlmm1_t);
            status = LmmProtocolAttributes(caller,
                (const scmi_msg_header_t*) in, (msg_tlmm1_t*) out);
            break;
        case COMMAND_PROTOCOL_MESSAGE_ATTRIBUTES:
            lenOut = sizeof(msg_tlmm2_t);
            status = LmmProtocolMessageAttributes(caller,
                (const msg_rlmm2_t*) in, (msg_tlmm2_t*) out);
            break;
        case COMMAND_LMM_ATTRIBUTES:
            lenOut = sizeof(msg_tlmm3_t);
            status = LmmAttributes(caller, (const msg_rlmm3_t*) in,
                (msg_tlmm3_t*) out);
            break;
        case COMMAND_LMM_BOOT:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmBoot(caller, (const msg_rlmm4_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_LMM_RESET:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmReset(caller, (const msg_rlmm5_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_LMM_SHUTDOWN:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmShutdown(caller, (const msg_rlmm6_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_LMM_WAKE:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmWake(caller, (const msg_rlmm7_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_LMM_SUSPEND:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmSuspend(caller, (const msg_rlmm8_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_LMM_NOTIFY:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmNotify(caller, (const msg_rlmm9_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_LMM_RESET_REASON:
            lenOut = sizeof(msg_tlmm10_t);
            status = LmmResetReason(caller, (const msg_rlmm10_t*) in,
                (msg_tlmm10_t*) out, &lenOut);
            break;
        case COMMAND_LMM_POWER_ON:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmPowerOn(caller, (const msg_rlmm11_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_LMM_RESET_VECTOR_SET:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmResetVectorSet(caller, (const msg_rlmm12_t*) in,
                (const scmi_msg_status_t*) out);
            break;
        case COMMAND_NEGOTIATE_PROTOCOL_VERSION:
            lenOut = sizeof(const scmi_msg_status_t);
            status = LmmNegotiateProtocolVersion(caller,
                (const msg_rlmm16_t*) in, (const scmi_msg_status_t*) out);
            break;
        default:
            status = SM_ERR_NOT_SUPPORTED;
            break;
    }

    /* Update length */
    caller->lenMsg = lenOut;

    /* Return status */
    return status;
}

Надо добавить в протокол команду перезапуска M7 LMM и установку вектора запуска. Вот готовая функция:
int32_t sm_m7_vector_reboot(uint32_t lm_id, uint32_t cpu_id, uint32_t boot_vector)
{
    lmm_rst_rec_t rstRec = {0};
    int32_t status = SM_ERR_SUCCESS;

    /* 1. Check the validity of the machine index */
    if (lm_id >= SM_NUM_LM)
    {
        printf("Invalid use lm_id=%d\n",lm_id);
        return SM_ERR_INVALID_PARAMETERS;
    }

    /* 2. Reset the RPC context to avoid SCMI communication channels hanging
    * between U-Boot/Linux and M33 during kernel restart. */
    status = LMM_RpcReset(lm_id);
    if (status != SM_ERR_SUCCESS)
    {
        printf("Error LMM_RpcReset status=%d\n",status);
        return status;
    }

    /* 3. Write the new startup vector to the hardware registers.*/
    status = LMM_CpuResetVectorSet(lm_id, cpu_id, boot_vector, true, true, false, true);
    if (status != SM_ERR_SUCCESS)
    {
        printf("Error DEV_SM_CpuResetVectorSet status=%d\n",status);
        return status;
    }
    status = LMM_SystemLmReset(0U, 0U, lm_id, true, false, &rstRec);
    printf("LMM_SystemLmReset status=%d\n",status);
    return status;
}

Команда на перезапуск будет из A55 u-boot либо из M7