GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)
This commit is contained in:
@@ -0,0 +1,73 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
#include <lib/mmio.h>
|
||||
|
||||
#include "imx8_mu.h"
|
||||
|
||||
void MU_Resume(uint32_t base)
|
||||
{
|
||||
uint32_t reg, i;
|
||||
|
||||
reg = mmio_read_32(base + MU_ACR_OFFSET1);
|
||||
/* Clear GIEn, RIEn, TIEn, GIRn and ABFn. */
|
||||
reg &= ~(MU_CR_GIEn_MASK1 | MU_CR_RIEn_MASK1 | MU_CR_TIEn_MASK1
|
||||
| MU_CR_GIRn_MASK1 | MU_CR_Fn_MASK1);
|
||||
mmio_write_32(base + MU_ACR_OFFSET1, reg);
|
||||
|
||||
/* Enable all RX interrupts */
|
||||
for (i = 0; i < MU_RR_COUNT; i++)
|
||||
MU_EnableRxFullInt(base, i);
|
||||
}
|
||||
|
||||
void MU_EnableRxFullInt(uint32_t base, uint32_t index)
|
||||
{
|
||||
uint32_t reg = mmio_read_32(base + MU_ACR_OFFSET1);
|
||||
|
||||
reg &= ~(MU_CR_GIRn_MASK1 | MU_CR_NMI_MASK1);
|
||||
reg |= MU_CR_RIE0_MASK1 >> index;
|
||||
mmio_write_32(base + MU_ACR_OFFSET1, reg);
|
||||
}
|
||||
|
||||
void MU_EnableGeneralInt(uint32_t base, uint32_t index)
|
||||
{
|
||||
uint32_t reg = mmio_read_32(base + MU_ACR_OFFSET1);
|
||||
|
||||
reg &= ~(MU_CR_GIRn_MASK1 | MU_CR_NMI_MASK1);
|
||||
reg |= MU_CR_GIE0_MASK1 >> index;
|
||||
mmio_write_32(base + MU_ACR_OFFSET1, reg);
|
||||
}
|
||||
|
||||
void MU_SendMessage(uint32_t base, uint32_t regIndex, uint32_t msg)
|
||||
{
|
||||
uint32_t mask = MU_SR_TE0_MASK1 >> regIndex;
|
||||
|
||||
/* Wait TX register to be empty. */
|
||||
while (!(mmio_read_32(base + MU_ASR_OFFSET1) & mask))
|
||||
;
|
||||
mmio_write_32(base + MU_ATR0_OFFSET1 + (regIndex * 4), msg);
|
||||
}
|
||||
|
||||
void MU_ReceiveMsg(uint32_t base, uint32_t regIndex, uint32_t *msg)
|
||||
{
|
||||
uint32_t mask = MU_SR_RF0_MASK1 >> regIndex;
|
||||
|
||||
/* Wait RX register to be full. */
|
||||
while (!(mmio_read_32(base + MU_ASR_OFFSET1) & mask))
|
||||
;
|
||||
*msg = mmio_read_32(base + MU_ARR0_OFFSET1 + (regIndex * 4));
|
||||
}
|
||||
|
||||
void MU_Init(uint32_t base)
|
||||
{
|
||||
uint32_t reg;
|
||||
|
||||
reg = mmio_read_32(base + MU_ACR_OFFSET1);
|
||||
/* Clear GIEn, RIEn, TIEn, GIRn and ABFn. */
|
||||
reg &= ~(MU_CR_GIEn_MASK1 | MU_CR_RIEn_MASK1 | MU_CR_TIEn_MASK1
|
||||
| MU_CR_GIRn_MASK1 | MU_CR_Fn_MASK1);
|
||||
mmio_write_32(base + MU_ACR_OFFSET1, reg);
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#define MU_ATR0_OFFSET1 0x0
|
||||
#define MU_ARR0_OFFSET1 0x10
|
||||
#define MU_ASR_OFFSET1 0x20
|
||||
#define MU_ACR_OFFSET1 0x24
|
||||
#define MU_TR_COUNT1 4
|
||||
#define MU_RR_COUNT1 4
|
||||
|
||||
#define MU_CR_GIEn_MASK1 (0xFu << 28)
|
||||
#define MU_CR_RIEn_MASK1 (0xF << 24)
|
||||
#define MU_CR_TIEn_MASK1 (0xF << 20)
|
||||
#define MU_CR_GIRn_MASK1 (0xF << 16)
|
||||
#define MU_CR_NMI_MASK1 (1 << 3)
|
||||
#define MU_CR_Fn_MASK1 0x7
|
||||
|
||||
#define MU_SR_TE0_MASK1 (1 << 23)
|
||||
#define MU_SR_RF0_MASK1 (1 << 27)
|
||||
#define MU_CR_RIE0_MASK1 (1 << 27)
|
||||
#define MU_CR_GIE0_MASK1 (1U << 31)
|
||||
|
||||
#define MU_TR_COUNT 4
|
||||
#define MU_RR_COUNT 4
|
||||
|
||||
void MU_Init(uint32_t base);
|
||||
void MU_SendMessage(uint32_t base, uint32_t regIndex, uint32_t msg);
|
||||
void MU_ReceiveMsg(uint32_t base, uint32_t regIndex, uint32_t *msg);
|
||||
void MU_EnableGeneralInt(uint32_t base, uint32_t index);
|
||||
void MU_EnableRxFullInt(uint32_t base, uint32_t index);
|
||||
void MU_Resume(uint32_t base);
|
||||
@@ -0,0 +1,120 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2019, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <lib/bakery_lock.h>
|
||||
|
||||
#include <sci/sci_scfw.h>
|
||||
#include <sci/sci_ipc.h>
|
||||
#include <sci/sci_rpc.h>
|
||||
#include "imx8_mu.h"
|
||||
|
||||
sc_ipc_t ipc_handle;
|
||||
|
||||
DEFINE_BAKERY_LOCK(sc_ipc_bakery_lock);
|
||||
#define sc_ipc_lock_init() bakery_lock_init(&sc_ipc_bakery_lock)
|
||||
#define sc_ipc_lock() bakery_lock_get(&sc_ipc_bakery_lock)
|
||||
#define sc_ipc_unlock() bakery_lock_release(&sc_ipc_bakery_lock)
|
||||
|
||||
void sc_call_rpc(sc_ipc_t ipc, sc_rpc_msg_t *msg, bool no_resp)
|
||||
{
|
||||
sc_ipc_lock();
|
||||
|
||||
sc_ipc_write(ipc, msg);
|
||||
if (!no_resp)
|
||||
sc_ipc_read(ipc, msg);
|
||||
|
||||
sc_ipc_unlock();
|
||||
}
|
||||
|
||||
sc_err_t sc_ipc_open(sc_ipc_t *ipc, sc_ipc_id_t id)
|
||||
{
|
||||
uint32_t base = id;
|
||||
uint32_t i;
|
||||
|
||||
/* Get MU base associated with IPC channel */
|
||||
if ((ipc == NULL) || (base == 0))
|
||||
return SC_ERR_IPC;
|
||||
|
||||
sc_ipc_lock_init();
|
||||
|
||||
/* Init MU */
|
||||
MU_Init(base);
|
||||
|
||||
/* Enable all RX interrupts */
|
||||
for (i = 0; i < MU_RR_COUNT; i++) {
|
||||
MU_EnableRxFullInt(base, i);
|
||||
}
|
||||
|
||||
/* Return MU address as handle */
|
||||
*ipc = (sc_ipc_t) id;
|
||||
|
||||
return SC_ERR_NONE;
|
||||
}
|
||||
|
||||
void sc_ipc_close(sc_ipc_t ipc)
|
||||
{
|
||||
uint32_t base = ipc;
|
||||
|
||||
if (base != 0)
|
||||
MU_Init(base);
|
||||
}
|
||||
|
||||
void sc_ipc_read(sc_ipc_t ipc, void *data)
|
||||
{
|
||||
uint32_t base = ipc;
|
||||
sc_rpc_msg_t *msg = (sc_rpc_msg_t *) data;
|
||||
uint8_t count = 0;
|
||||
|
||||
/* Check parms */
|
||||
if ((base == 0) || (msg == NULL))
|
||||
return;
|
||||
|
||||
/* Read first word */
|
||||
MU_ReceiveMsg(base, 0, (uint32_t *) msg);
|
||||
count++;
|
||||
|
||||
/* Check size */
|
||||
if (msg->size > SC_RPC_MAX_MSG) {
|
||||
*((uint32_t *) msg) = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
/* Read remaining words */
|
||||
while (count < msg->size) {
|
||||
MU_ReceiveMsg(base, count % MU_RR_COUNT,
|
||||
&(msg->DATA.u32[count - 1]));
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
void sc_ipc_write(sc_ipc_t ipc, void *data)
|
||||
{
|
||||
sc_rpc_msg_t *msg = (sc_rpc_msg_t *) data;
|
||||
uint32_t base = ipc;
|
||||
uint8_t count = 0;
|
||||
|
||||
/* Check parms */
|
||||
if ((base == 0) || (msg == NULL))
|
||||
return;
|
||||
|
||||
/* Check size */
|
||||
if (msg->size > SC_RPC_MAX_MSG)
|
||||
return;
|
||||
|
||||
/* Write first word */
|
||||
MU_SendMessage(base, 0, *((uint32_t *) msg));
|
||||
count++;
|
||||
|
||||
/* Write remaining words */
|
||||
while (count < msg->size) {
|
||||
MU_SendMessage(base, count % MU_TR_COUNT,
|
||||
msg->DATA.u32[count - 1]);
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
#
|
||||
# Copyright (c) 2015-2019, ARM Limited and Contributors. All rights reserved.
|
||||
#
|
||||
# SPDX-License-Identifier: BSD-3-Clause
|
||||
#
|
||||
|
||||
BL31_SOURCES += plat/imx/common/sci/ipc.c \
|
||||
plat/imx/common/sci/imx8_mu.c \
|
||||
plat/imx/common/sci/svc/pad/pad_rpc_clnt.c \
|
||||
plat/imx/common/sci/svc/pm/pm_rpc_clnt.c \
|
||||
plat/imx/common/sci/svc/rm/rm_rpc_clnt.c \
|
||||
plat/imx/common/sci/svc/timer/timer_rpc_clnt.c \
|
||||
plat/imx/common/sci/svc/misc/misc_rpc_clnt.c
|
||||
+506
@@ -0,0 +1,506 @@
|
||||
/*
|
||||
* Copyright (C) 2016 Freescale Semiconductor, Inc.
|
||||
* Copyright 2017-2018 NXP
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* File containing client-side RPC functions for the MISC service. These
|
||||
* functions are ported to clients that communicate to the SC.
|
||||
*
|
||||
* @addtogroup MISC_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* Includes */
|
||||
|
||||
#include <sci/sci_types.h>
|
||||
#include <sci/svc/rm/sci_rm_api.h>
|
||||
#include <sci/svc/misc/sci_misc_api.h>
|
||||
#include <sci/sci_rpc.h>
|
||||
#include <stdlib.h>
|
||||
#include "sci_misc_rpc.h"
|
||||
|
||||
/* Local Defines */
|
||||
|
||||
/* Local Types */
|
||||
|
||||
/* Local Functions */
|
||||
|
||||
sc_err_t sc_misc_set_control(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_ctrl_t ctrl, uint32_t val)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SET_CONTROL;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)ctrl;
|
||||
RPC_U32(&msg, 4U) = (uint32_t)val;
|
||||
RPC_U16(&msg, 8U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 4U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_get_control(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_ctrl_t ctrl, uint32_t *val)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_GET_CONTROL;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)ctrl;
|
||||
RPC_U16(&msg, 4U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (val != NULL)
|
||||
*val = RPC_U32(&msg, 0U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_set_max_dma_group(sc_ipc_t ipc, sc_rm_pt_t pt,
|
||||
sc_misc_dma_group_t max)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SET_MAX_DMA_GROUP;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)max;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_set_dma_group(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_misc_dma_group_t group)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SET_DMA_GROUP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)group;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_seco_image_load(sc_ipc_t ipc, sc_faddr_t addr_src,
|
||||
sc_faddr_t addr_dst, uint32_t len,
|
||||
sc_bool_t fw)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_IMAGE_LOAD;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr_src >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr_src;
|
||||
RPC_U32(&msg, 8U) = (uint32_t)(addr_dst >> 32U);
|
||||
RPC_U32(&msg, 12U) = (uint32_t)addr_dst;
|
||||
RPC_U32(&msg, 16U) = (uint32_t)len;
|
||||
RPC_U8(&msg, 20U) = (uint8_t)fw;
|
||||
RPC_SIZE(&msg) = 7U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_seco_authenticate(sc_ipc_t ipc,
|
||||
sc_misc_seco_auth_cmd_t cmd, sc_faddr_t addr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_AUTHENTICATE;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr;
|
||||
RPC_U8(&msg, 8U) = (uint8_t)cmd;
|
||||
RPC_SIZE(&msg) = 4U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_seco_fuse_write(sc_ipc_t ipc, sc_faddr_t addr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_FUSE_WRITE;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_seco_enable_debug(sc_ipc_t ipc, sc_faddr_t addr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_ENABLE_DEBUG;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_seco_forward_lifecycle(sc_ipc_t ipc, uint32_t lifecycle)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_FORWARD_LIFECYCLE;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)lifecycle;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_seco_return_lifecycle(sc_ipc_t ipc, sc_faddr_t addr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_RETURN_LIFECYCLE;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
void sc_misc_seco_build_info(sc_ipc_t ipc, uint32_t *version, uint32_t *commit)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_BUILD_INFO;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (version != NULL)
|
||||
*version = RPC_U32(&msg, 0U);
|
||||
|
||||
if (commit != NULL)
|
||||
*commit = RPC_U32(&msg, 4U);
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_seco_chip_info(sc_ipc_t ipc, uint16_t *lc,
|
||||
uint16_t *monotonic, uint32_t *uid_l,
|
||||
uint32_t *uid_h)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SECO_CHIP_INFO;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (uid_l != NULL)
|
||||
*uid_l = RPC_U32(&msg, 0U);
|
||||
|
||||
if (uid_h != NULL)
|
||||
*uid_h = RPC_U32(&msg, 4U);
|
||||
|
||||
if (lc != NULL)
|
||||
*lc = RPC_U16(&msg, 8U);
|
||||
|
||||
if (monotonic != NULL)
|
||||
*monotonic = RPC_U16(&msg, 10U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
void sc_misc_debug_out(sc_ipc_t ipc, uint8_t ch)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_DEBUG_OUT;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)ch;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_waveform_capture(sc_ipc_t ipc, sc_bool_t enable)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_WAVEFORM_CAPTURE;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)enable;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
void sc_misc_build_info(sc_ipc_t ipc, uint32_t *build, uint32_t *commit)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_BUILD_INFO;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (build != NULL)
|
||||
*build = RPC_U32(&msg, 0U);
|
||||
|
||||
if (commit != NULL)
|
||||
*commit = RPC_U32(&msg, 4U);
|
||||
}
|
||||
|
||||
void sc_misc_unique_id(sc_ipc_t ipc, uint32_t *id_l, uint32_t *id_h)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_UNIQUE_ID;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (id_l != NULL)
|
||||
*id_l = RPC_U32(&msg, 0U);
|
||||
|
||||
if (id_h != NULL)
|
||||
*id_h = RPC_U32(&msg, 4U);
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_set_ari(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_rsrc_t resource_mst, uint16_t ari, sc_bool_t enable)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SET_ARI;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U16(&msg, 2U) = (uint16_t)resource_mst;
|
||||
RPC_U16(&msg, 4U) = (uint16_t)ari;
|
||||
RPC_U8(&msg, 6U) = (uint8_t)enable;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
void sc_misc_boot_status(sc_ipc_t ipc, sc_misc_boot_status_t status)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_BOOT_STATUS;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)status;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_TRUE);
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_boot_done(sc_ipc_t ipc, sc_rsrc_t cpu)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_BOOT_DONE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)cpu;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_otp_fuse_read(sc_ipc_t ipc, uint32_t word, uint32_t *val)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_OTP_FUSE_READ;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)word;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (val != NULL)
|
||||
*val = RPC_U32(&msg, 0U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_otp_fuse_write(sc_ipc_t ipc, uint32_t word, uint32_t val)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_OTP_FUSE_WRITE;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)word;
|
||||
RPC_U32(&msg, 4U) = (uint32_t)val;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_set_temp(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_misc_temp_t temp, int16_t celsius, int8_t tenths)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_SET_TEMP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_I16(&msg, 2U) = (int16_t) celsius;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)temp;
|
||||
RPC_I8(&msg, 5U) = (int8_t) tenths;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_misc_get_temp(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_misc_temp_t temp, int16_t *celsius,
|
||||
int8_t *tenths)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_GET_TEMP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)temp;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (celsius != NULL)
|
||||
*celsius = RPC_I16(&msg, 0U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (tenths != NULL)
|
||||
*tenths = RPC_I8(&msg, 2U);
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
void sc_misc_get_boot_dev(sc_ipc_t ipc, sc_rsrc_t *dev)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_GET_BOOT_DEV;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (dev != NULL)
|
||||
*dev = RPC_U16(&msg, 0U);
|
||||
}
|
||||
|
||||
void sc_misc_get_button_status(sc_ipc_t ipc, sc_bool_t *status)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_MISC;
|
||||
RPC_FUNC(&msg) = (uint8_t)MISC_FUNC_GET_BUTTON_STATUS;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (status != NULL)
|
||||
*status = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
/**@}*/
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* Copyright (C) 2016 Freescale Semiconductor, Inc.
|
||||
* Copyright 2017-2019 NXP
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* Header file for the MISC RPC implementation.
|
||||
*
|
||||
* @addtogroup MISC_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifndef SC_MISC_RPC_H
|
||||
#define SC_MISC_RPC_H
|
||||
|
||||
/* Includes */
|
||||
|
||||
/* Defines */
|
||||
|
||||
/*!
|
||||
* @name Defines for RPC MISC function calls
|
||||
*/
|
||||
/*@{*/
|
||||
#define MISC_FUNC_UNKNOWN 0 /* Unknown function */
|
||||
#define MISC_FUNC_SET_CONTROL 1U /* Index for misc_set_control() RPC call */
|
||||
#define MISC_FUNC_GET_CONTROL 2U /* Index for misc_get_control() RPC call */
|
||||
#define MISC_FUNC_SET_MAX_DMA_GROUP 4U /* Index for misc_set_max_dma_group() RPC call */
|
||||
#define MISC_FUNC_SET_DMA_GROUP 5U /* Index for misc_set_dma_group() RPC call */
|
||||
#define MISC_FUNC_SECO_IMAGE_LOAD 8U /* Index for misc_seco_image_load() RPC call */
|
||||
#define MISC_FUNC_SECO_AUTHENTICATE 9U /* Index for misc_seco_authenticate() RPC call */
|
||||
#define MISC_FUNC_SECO_FUSE_WRITE 20U /* Index for misc_seco_fuse_write() RPC call */
|
||||
#define MISC_FUNC_SECO_ENABLE_DEBUG 21U /* Index for misc_seco_enable_debug() RPC call */
|
||||
#define MISC_FUNC_SECO_FORWARD_LIFECYCLE 22U /* Index for misc_seco_forward_lifecycle() RPC call */
|
||||
#define MISC_FUNC_SECO_RETURN_LIFECYCLE 23U /* Index for misc_seco_return_lifecycle() RPC call */
|
||||
#define MISC_FUNC_SECO_BUILD_INFO 24U /* Index for misc_seco_build_info() RPC call */
|
||||
#define MISC_FUNC_SECO_CHIP_INFO 25U /* Index for misc_seco_chip_info() RPC call */
|
||||
#define MISC_FUNC_DEBUG_OUT 10U /* Index for misc_debug_out() RPC call */
|
||||
#define MISC_FUNC_WAVEFORM_CAPTURE 6U /* Index for misc_waveform_capture() RPC call */
|
||||
#define MISC_FUNC_BUILD_INFO 15U /* Index for misc_build_info() RPC call */
|
||||
#define MISC_FUNC_UNIQUE_ID 19U /* Index for misc_unique_id() RPC call */
|
||||
#define MISC_FUNC_SET_ARI 3U /* Index for misc_set_ari() RPC call */
|
||||
#define MISC_FUNC_BOOT_STATUS 7U /* Index for misc_boot_status() RPC call */
|
||||
#define MISC_FUNC_BOOT_DONE 14U /* Index for misc_boot_done() RPC call */
|
||||
#define MISC_FUNC_OTP_FUSE_READ 11U /* Index for misc_otp_fuse_read() RPC call */
|
||||
#define MISC_FUNC_OTP_FUSE_WRITE 17U /* Index for misc_otp_fuse_write() RPC call */
|
||||
#define MISC_FUNC_SET_TEMP 12U /* Index for misc_set_temp() RPC call */
|
||||
#define MISC_FUNC_GET_TEMP 13U /* Index for misc_get_temp() RPC call */
|
||||
#define MISC_FUNC_GET_BOOT_DEV 16U /* Index for misc_get_boot_dev() RPC call */
|
||||
#define MISC_FUNC_GET_BUTTON_STATUS 18U /* Index for misc_get_button_status() RPC call */
|
||||
/*@}*/
|
||||
|
||||
/* Types */
|
||||
|
||||
/* Functions */
|
||||
|
||||
/*!
|
||||
* This function dispatches an incoming MISC RPC request.
|
||||
*
|
||||
* @param[in] caller_pt caller partition
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void misc_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg);
|
||||
|
||||
/*!
|
||||
* This function translates and dispatches an MISC RPC request.
|
||||
*
|
||||
* @param[in] ipc IPC handle
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void misc_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
|
||||
|
||||
#endif /* SC_MISC_RPC_H */
|
||||
|
||||
/**@}*/
|
||||
+454
@@ -0,0 +1,454 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* File containing client-side RPC functions for the PAD service. These
|
||||
* functions are ported to clients that communicate to the SC.
|
||||
*
|
||||
* @addtogroup PAD_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* Includes */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <sci/sci_types.h>
|
||||
#include <sci/svc/rm/sci_rm_api.h>
|
||||
#include <sci/svc/pad/sci_pad_api.h>
|
||||
#include <sci/sci_rpc.h>
|
||||
#include "sci_pad_rpc.h"
|
||||
|
||||
/* Local Defines */
|
||||
|
||||
/* Local Types */
|
||||
|
||||
/* Local Functions */
|
||||
|
||||
sc_err_t sc_pad_set_mux(sc_ipc_t ipc, sc_pad_t pad,
|
||||
uint8_t mux, sc_pad_config_t config, sc_pad_iso_t iso)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET_MUX;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)mux;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)config;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)iso;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get_mux(sc_ipc_t ipc, sc_pad_t pad,
|
||||
uint8_t *mux, sc_pad_config_t *config,
|
||||
sc_pad_iso_t *iso)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET_MUX;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mux != NULL) {
|
||||
*mux = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
if (config != NULL) {
|
||||
*config = RPC_U8(&msg, 1U);
|
||||
}
|
||||
|
||||
if (iso != NULL) {
|
||||
*iso = RPC_U8(&msg, 2U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_set_gp(sc_ipc_t ipc, sc_pad_t pad, uint32_t ctrl)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET_GP;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)ctrl;
|
||||
RPC_U16(&msg, 4U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get_gp(sc_ipc_t ipc, sc_pad_t pad, uint32_t *ctrl)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET_GP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (ctrl != NULL) {
|
||||
*ctrl = RPC_U32(&msg, 0U);
|
||||
}
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_set_wakeup(sc_ipc_t ipc, sc_pad_t pad, sc_pad_wakeup_t wakeup)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET_WAKEUP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)wakeup;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get_wakeup(sc_ipc_t ipc, sc_pad_t pad, sc_pad_wakeup_t *wakeup)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET_WAKEUP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (wakeup != NULL) {
|
||||
*wakeup = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_set_all(sc_ipc_t ipc, sc_pad_t pad, uint8_t mux,
|
||||
sc_pad_config_t config, sc_pad_iso_t iso, uint32_t ctrl,
|
||||
sc_pad_wakeup_t wakeup)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET_ALL;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)ctrl;
|
||||
RPC_U16(&msg, 4U) = (uint16_t)pad;
|
||||
RPC_U8(&msg, 6U) = (uint8_t)mux;
|
||||
RPC_U8(&msg, 7U) = (uint8_t)config;
|
||||
RPC_U8(&msg, 8U) = (uint8_t)iso;
|
||||
RPC_U8(&msg, 9U) = (uint8_t)wakeup;
|
||||
RPC_SIZE(&msg) = 4U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get_all(sc_ipc_t ipc, sc_pad_t pad, uint8_t *mux,
|
||||
sc_pad_config_t *config, sc_pad_iso_t *iso,
|
||||
uint32_t *ctrl, sc_pad_wakeup_t *wakeup)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET_ALL;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (ctrl != NULL) {
|
||||
*ctrl = RPC_U32(&msg, 0U);
|
||||
}
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mux != NULL) {
|
||||
*mux = RPC_U8(&msg, 4U);
|
||||
}
|
||||
|
||||
if (config != NULL) {
|
||||
*config = RPC_U8(&msg, 5U);
|
||||
}
|
||||
|
||||
if (iso != NULL) {
|
||||
*iso = RPC_U8(&msg, 6U);
|
||||
}
|
||||
|
||||
if (wakeup != NULL) {
|
||||
*wakeup = RPC_U8(&msg, 7U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_set(sc_ipc_t ipc, sc_pad_t pad, uint32_t val)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)val;
|
||||
RPC_U16(&msg, 4U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get(sc_ipc_t ipc, sc_pad_t pad, uint32_t *val)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (val != NULL) {
|
||||
*val = RPC_U32(&msg, 0U);
|
||||
}
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_set_gp_28fdsoi(sc_ipc_t ipc, sc_pad_t pad,
|
||||
sc_pad_28fdsoi_dse_t dse, sc_pad_28fdsoi_ps_t ps)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET_GP_28FDSOI;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)dse;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)ps;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get_gp_28fdsoi(sc_ipc_t ipc, sc_pad_t pad,
|
||||
sc_pad_28fdsoi_dse_t *dse,
|
||||
sc_pad_28fdsoi_ps_t *ps)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET_GP_28FDSOI;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (dse != NULL) {
|
||||
*dse = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
if (ps != NULL) {
|
||||
*ps = RPC_U8(&msg, 1U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_set_gp_28fdsoi_hsic(sc_ipc_t ipc, sc_pad_t pad,
|
||||
sc_pad_28fdsoi_dse_t dse, sc_bool_t hys,
|
||||
sc_pad_28fdsoi_pus_t pus, sc_bool_t pke,
|
||||
sc_bool_t pue)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET_GP_28FDSOI_HSIC;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)dse;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)pus;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)hys;
|
||||
RPC_U8(&msg, 5U) = (uint8_t)pke;
|
||||
RPC_U8(&msg, 6U) = (uint8_t)pue;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get_gp_28fdsoi_hsic(sc_ipc_t ipc, sc_pad_t pad,
|
||||
sc_pad_28fdsoi_dse_t *dse, sc_bool_t *hys,
|
||||
sc_pad_28fdsoi_pus_t *pus, sc_bool_t *pke,
|
||||
sc_bool_t *pue)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET_GP_28FDSOI_HSIC;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (dse != NULL) {
|
||||
*dse = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
if (pus != NULL) {
|
||||
*pus = RPC_U8(&msg, 1U);
|
||||
}
|
||||
|
||||
if (hys != NULL) {
|
||||
*hys = RPC_U8(&msg, 2U);
|
||||
}
|
||||
|
||||
if (pke != NULL) {
|
||||
*pke = RPC_U8(&msg, 3U);
|
||||
}
|
||||
|
||||
if (pue != NULL) {
|
||||
*pue = RPC_U8(&msg, 4U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_set_gp_28fdsoi_comp(sc_ipc_t ipc, sc_pad_t pad,
|
||||
uint8_t compen, sc_bool_t fastfrz,
|
||||
uint8_t rasrcp, uint8_t rasrcn,
|
||||
sc_bool_t nasrc_sel, sc_bool_t psw_ovr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_SET_GP_28FDSOI_COMP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)compen;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)rasrcp;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)rasrcn;
|
||||
RPC_U8(&msg, 5U) = (uint8_t)fastfrz;
|
||||
RPC_U8(&msg, 6U) = (uint8_t)nasrc_sel;
|
||||
RPC_U8(&msg, 7U) = (uint8_t)psw_ovr;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pad_get_gp_28fdsoi_comp(sc_ipc_t ipc, sc_pad_t pad,
|
||||
uint8_t *compen, sc_bool_t *fastfrz,
|
||||
uint8_t *rasrcp, uint8_t *rasrcn,
|
||||
sc_bool_t *nasrc_sel, sc_bool_t *compok,
|
||||
uint8_t *nasrc, sc_bool_t *psw_ovr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PAD;
|
||||
RPC_FUNC(&msg) = (uint8_t)PAD_FUNC_GET_GP_28FDSOI_COMP;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (compen != NULL) {
|
||||
*compen = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
if (rasrcp != NULL) {
|
||||
*rasrcp = RPC_U8(&msg, 1U);
|
||||
}
|
||||
|
||||
if (rasrcn != NULL) {
|
||||
*rasrcn = RPC_U8(&msg, 2U);
|
||||
}
|
||||
|
||||
if (nasrc != NULL) {
|
||||
*nasrc = RPC_U8(&msg, 3U);
|
||||
}
|
||||
|
||||
if (fastfrz != NULL) {
|
||||
*fastfrz = RPC_U8(&msg, 4U);
|
||||
}
|
||||
|
||||
if (nasrc_sel != NULL) {
|
||||
*nasrc_sel = RPC_U8(&msg, 5U);
|
||||
}
|
||||
|
||||
if (compok != NULL) {
|
||||
*compok = RPC_U8(&msg, 6U);
|
||||
}
|
||||
|
||||
if (psw_ovr != NULL) {
|
||||
*psw_ovr = RPC_U8(&msg, 7U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
/**@}*/
|
||||
+66
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* Header file for the PAD RPC implementation.
|
||||
*
|
||||
* @addtogroup PAD_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifndef SCI_PAD_RPC_H
|
||||
#define SCI_PAD_RPC_H
|
||||
|
||||
/* Includes */
|
||||
|
||||
/* Defines */
|
||||
|
||||
/*!
|
||||
* @name Defines for RPC PAD function calls
|
||||
*/
|
||||
/*@{*/
|
||||
#define PAD_FUNC_UNKNOWN 0 /* Unknown function */
|
||||
#define PAD_FUNC_SET_MUX 1U /* Index for pad_set_mux() RPC call */
|
||||
#define PAD_FUNC_GET_MUX 6U /* Index for pad_get_mux() RPC call */
|
||||
#define PAD_FUNC_SET_GP 2U /* Index for pad_set_gp() RPC call */
|
||||
#define PAD_FUNC_GET_GP 7U /* Index for pad_get_gp() RPC call */
|
||||
#define PAD_FUNC_SET_WAKEUP 4U /* Index for pad_set_wakeup() RPC call */
|
||||
#define PAD_FUNC_GET_WAKEUP 9U /* Index for pad_get_wakeup() RPC call */
|
||||
#define PAD_FUNC_SET_ALL 5U /* Index for pad_set_all() RPC call */
|
||||
#define PAD_FUNC_GET_ALL 10U /* Index for pad_get_all() RPC call */
|
||||
#define PAD_FUNC_SET 15U /* Index for pad_set() RPC call */
|
||||
#define PAD_FUNC_GET 16U /* Index for pad_get() RPC call */
|
||||
#define PAD_FUNC_SET_GP_28FDSOI 11U /* Index for pad_set_gp_28fdsoi() RPC call */
|
||||
#define PAD_FUNC_GET_GP_28FDSOI 12U /* Index for pad_get_gp_28fdsoi() RPC call */
|
||||
#define PAD_FUNC_SET_GP_28FDSOI_HSIC 3U /* Index for pad_set_gp_28fdsoi_hsic() RPC call */
|
||||
#define PAD_FUNC_GET_GP_28FDSOI_HSIC 8U /* Index for pad_get_gp_28fdsoi_hsic() RPC call */
|
||||
#define PAD_FUNC_SET_GP_28FDSOI_COMP 13U /* Index for pad_set_gp_28fdsoi_comp() RPC call */
|
||||
#define PAD_FUNC_GET_GP_28FDSOI_COMP 14U /* Index for pad_get_gp_28fdsoi_comp() RPC call */
|
||||
/*@}*/
|
||||
|
||||
/* Types */
|
||||
|
||||
/* Functions */
|
||||
|
||||
/*!
|
||||
* This function dispatches an incoming PAD RPC request.
|
||||
*
|
||||
* @param[in] caller_pt caller partition
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void pad_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg);
|
||||
|
||||
/*!
|
||||
* This function translates and dispatches an PAD RPC request.
|
||||
*
|
||||
* @param[in] ipc IPC handle
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void pad_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
|
||||
|
||||
#endif /* SCI_PAD_RPC_H */
|
||||
|
||||
/**@}*/
|
||||
+459
@@ -0,0 +1,459 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* File containing client-side RPC functions for the PM service. These
|
||||
* functions are ported to clients that communicate to the SC.
|
||||
*
|
||||
* @addtogroup PM_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* Includes */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <sci/sci_types.h>
|
||||
#include <sci/svc/rm/sci_rm_api.h>
|
||||
#include <sci/svc/pm/sci_pm_api.h>
|
||||
#include <sci/sci_rpc.h>
|
||||
|
||||
#include "sci_pm_rpc.h"
|
||||
|
||||
/* Local Defines */
|
||||
|
||||
/* Local Types */
|
||||
|
||||
/* Local Functions */
|
||||
|
||||
sc_err_t sc_pm_set_sys_power_mode(sc_ipc_t ipc, sc_pm_power_mode_t mode)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_SET_SYS_POWER_MODE;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)mode;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_set_partition_power_mode(sc_ipc_t ipc, sc_rm_pt_t pt,
|
||||
sc_pm_power_mode_t mode)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_SET_PARTITION_POWER_MODE;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)mode;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_get_sys_power_mode(sc_ipc_t ipc, sc_rm_pt_t pt,
|
||||
sc_pm_power_mode_t *mode)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_GET_SYS_POWER_MODE;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mode != NULL) {
|
||||
*mode = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_set_resource_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_power_mode_t mode)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_SET_RESOURCE_POWER_MODE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)mode;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_get_resource_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_power_mode_t *mode)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_GET_RESOURCE_POWER_MODE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mode != NULL) {
|
||||
*mode = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_req_low_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_power_mode_t mode)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_REQ_LOW_POWER_MODE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)mode;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_req_cpu_low_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_power_mode_t mode,
|
||||
sc_pm_wake_src_t wake_src)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_REQ_CPU_LOW_POWER_MODE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)mode;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)wake_src;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_set_cpu_resume_addr(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_faddr_t address)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_SET_CPU_RESUME_ADDR;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(address >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)address;
|
||||
RPC_U16(&msg, 8U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 4U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_set_cpu_resume(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_bool_t isPrimary, sc_faddr_t address)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_SET_CPU_RESUME;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(address >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)address;
|
||||
RPC_U16(&msg, 8U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 10U) = (uint8_t)isPrimary;
|
||||
RPC_SIZE(&msg) = 4U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_req_sys_if_power_mode(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_sys_if_t sys_if,
|
||||
sc_pm_power_mode_t hpm,
|
||||
sc_pm_power_mode_t lpm)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_REQ_SYS_IF_POWER_MODE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)sys_if;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)hpm;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)lpm;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_set_clock_rate(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_clk_t clk, sc_pm_clock_rate_t *rate)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_SET_CLOCK_RATE;
|
||||
RPC_U32(&msg, 0U) = *(uint32_t *)rate;
|
||||
RPC_U16(&msg, 4U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 6U) = (uint8_t)clk;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
*rate = RPC_U32(&msg, 0U);
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_get_clock_rate(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_clk_t clk, sc_pm_clock_rate_t *rate)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_GET_CLOCK_RATE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)clk;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (rate != NULL) {
|
||||
*rate = RPC_U32(&msg, 0U);
|
||||
}
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_clock_enable(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_clk_t clk, sc_bool_t enable, sc_bool_t autog)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_CLOCK_ENABLE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)clk;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)enable;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)autog;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_set_clock_parent(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_clk_t clk, sc_pm_clk_parent_t parent)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_SET_CLOCK_PARENT;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)clk;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)parent;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_get_clock_parent(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_pm_clk_t clk, sc_pm_clk_parent_t *parent)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_GET_CLOCK_PARENT;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)clk;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (parent != NULL) {
|
||||
*parent = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_reset(sc_ipc_t ipc, sc_pm_reset_type_t type)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_RESET;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)type;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_reset_reason(sc_ipc_t ipc, sc_pm_reset_reason_t *reason)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_RESET_REASON;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (reason != NULL) {
|
||||
*reason = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_boot(sc_ipc_t ipc, sc_rm_pt_t pt,
|
||||
sc_rsrc_t resource_cpu, sc_faddr_t boot_addr,
|
||||
sc_rsrc_t resource_mu, sc_rsrc_t resource_dev)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_BOOT;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(boot_addr >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)boot_addr;
|
||||
RPC_U16(&msg, 8U) = (uint16_t)resource_cpu;
|
||||
RPC_U16(&msg, 10U) = (uint16_t)resource_mu;
|
||||
RPC_U16(&msg, 12U) = (uint16_t)resource_dev;
|
||||
RPC_U8(&msg, 14U) = (uint8_t)pt;
|
||||
RPC_SIZE(&msg) = 5U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
void sc_pm_reboot(sc_ipc_t ipc, sc_pm_reset_type_t type)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_REBOOT;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)type;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_TRUE);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_reboot_partition(sc_ipc_t ipc, sc_rm_pt_t pt,
|
||||
sc_pm_reset_type_t type)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_REBOOT_PARTITION;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)type;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_pm_cpu_start(sc_ipc_t ipc, sc_rsrc_t resource, sc_bool_t enable,
|
||||
sc_faddr_t address)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_PM;
|
||||
RPC_FUNC(&msg) = (uint8_t)PM_FUNC_CPU_START;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(address >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)address;
|
||||
RPC_U16(&msg, 8U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 10U) = (uint8_t)enable;
|
||||
RPC_SIZE(&msg) = 4U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
/**@}*/
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* Header file for the PM RPC implementation.
|
||||
*
|
||||
* @addtogroup PM_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifndef SCI_PM_RPC_H
|
||||
#define SCI_PM_RPC_H
|
||||
|
||||
/* Includes */
|
||||
|
||||
/* Defines */
|
||||
|
||||
/*!
|
||||
* @name Defines for RPC PM function calls
|
||||
*/
|
||||
/*@{*/
|
||||
#define PM_FUNC_UNKNOWN 0 /* Unknown function */
|
||||
#define PM_FUNC_SET_SYS_POWER_MODE 19U /* Index for pm_set_sys_power_mode() RPC call */
|
||||
#define PM_FUNC_SET_PARTITION_POWER_MODE 1U /* Index for pm_set_partition_power_mode() RPC call */
|
||||
#define PM_FUNC_GET_SYS_POWER_MODE 2U /* Index for pm_get_sys_power_mode() RPC call */
|
||||
#define PM_FUNC_SET_RESOURCE_POWER_MODE 3U /* Index for pm_set_resource_power_mode() RPC call */
|
||||
#define PM_FUNC_GET_RESOURCE_POWER_MODE 4U /* Index for pm_get_resource_power_mode() RPC call */
|
||||
#define PM_FUNC_REQ_LOW_POWER_MODE 16U /* Index for pm_req_low_power_mode() RPC call */
|
||||
#define PM_FUNC_REQ_CPU_LOW_POWER_MODE 20U /* Index for pm_req_cpu_low_power_mode() RPC call */
|
||||
#define PM_FUNC_SET_CPU_RESUME_ADDR 17U /* Index for pm_set_cpu_resume_addr() RPC call */
|
||||
#define PM_FUNC_SET_CPU_RESUME 21U /* Index for pm_set_cpu_resume() RPC call */
|
||||
#define PM_FUNC_REQ_SYS_IF_POWER_MODE 18U /* Index for pm_req_sys_if_power_mode() RPC call */
|
||||
#define PM_FUNC_SET_CLOCK_RATE 5U /* Index for pm_set_clock_rate() RPC call */
|
||||
#define PM_FUNC_GET_CLOCK_RATE 6U /* Index for pm_get_clock_rate() RPC call */
|
||||
#define PM_FUNC_CLOCK_ENABLE 7U /* Index for pm_clock_enable() RPC call */
|
||||
#define PM_FUNC_SET_CLOCK_PARENT 14U /* Index for pm_set_clock_parent() RPC call */
|
||||
#define PM_FUNC_GET_CLOCK_PARENT 15U /* Index for pm_get_clock_parent() RPC call */
|
||||
#define PM_FUNC_RESET 13U /* Index for pm_reset() RPC call */
|
||||
#define PM_FUNC_RESET_REASON 10U /* Index for pm_reset_reason() RPC call */
|
||||
#define PM_FUNC_BOOT 8U /* Index for pm_boot() RPC call */
|
||||
#define PM_FUNC_REBOOT 9U /* Index for pm_reboot() RPC call */
|
||||
#define PM_FUNC_REBOOT_PARTITION 12U /* Index for pm_reboot_partition() RPC call */
|
||||
#define PM_FUNC_CPU_START 11U /* Index for pm_cpu_start() RPC call */
|
||||
/*@}*/
|
||||
|
||||
/* Types */
|
||||
|
||||
/* Functions */
|
||||
|
||||
/*!
|
||||
* This function dispatches an incoming PM RPC request.
|
||||
*
|
||||
* @param[in] caller_pt caller partition
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void pm_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg);
|
||||
|
||||
/*!
|
||||
* This function translates and dispatches an PM RPC request.
|
||||
*
|
||||
* @param[in] ipc IPC handle
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void pm_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
|
||||
|
||||
#endif /* SCI_PM_RPC_H */
|
||||
|
||||
/**@}*/
|
||||
+639
@@ -0,0 +1,639 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* File containing client-side RPC functions for the RM service. These
|
||||
* functions are ported to clients that communicate to the SC.
|
||||
*
|
||||
* @addtogroup RM_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* Includes */
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <sci/sci_types.h>
|
||||
#include <sci/svc/rm/sci_rm_api.h>
|
||||
#include <sci/sci_rpc.h>
|
||||
|
||||
#include "sci_rm_rpc.h"
|
||||
|
||||
/* Local Defines */
|
||||
|
||||
/* Local Types */
|
||||
|
||||
/* Local Functions */
|
||||
|
||||
sc_err_t sc_rm_partition_alloc(sc_ipc_t ipc, sc_rm_pt_t *pt, sc_bool_t secure,
|
||||
sc_bool_t isolated, sc_bool_t restricted,
|
||||
sc_bool_t grant, sc_bool_t coherent)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_ALLOC;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)secure;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)isolated;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)restricted;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)grant;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)coherent;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (pt != NULL) {
|
||||
*pt = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_confidential(sc_ipc_t ipc, sc_rm_pt_t pt, sc_bool_t retro)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_CONFIDENTIAL;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)retro;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_partition_free(sc_ipc_t ipc, sc_rm_pt_t pt)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_FREE;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_rm_did_t sc_rm_get_did(sc_ipc_t ipc)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_DID;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_rm_did_t) result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_partition_static(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_did_t did)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_STATIC;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)did;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_partition_lock(sc_ipc_t ipc, sc_rm_pt_t pt)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_PARTITION_LOCK;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_get_partition(sc_ipc_t ipc, sc_rm_pt_t *pt)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_PARTITION;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (pt != NULL) {
|
||||
*pt = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_parent(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_pt_t pt_parent)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_PARENT;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)pt_parent;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_move_all(sc_ipc_t ipc, sc_rm_pt_t pt_src, sc_rm_pt_t pt_dst,
|
||||
sc_bool_t move_rsrc, sc_bool_t move_pads)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MOVE_ALL;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt_src;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)pt_dst;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)move_rsrc;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)move_pads;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_assign_resource(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rsrc_t resource)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_ASSIGN_RESOURCE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)pt;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_resource_movable(sc_ipc_t ipc, sc_rsrc_t resource_fst,
|
||||
sc_rsrc_t resource_lst, sc_bool_t movable)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_RESOURCE_MOVABLE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource_fst;
|
||||
RPC_U16(&msg, 2U) = (uint16_t)resource_lst;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)movable;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_subsys_rsrc_movable(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_bool_t movable)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_SUBSYS_RSRC_MOVABLE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)movable;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_master_attributes(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_rm_spa_t sa, sc_rm_spa_t pa,
|
||||
sc_bool_t smmu_bypass)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_MASTER_ATTRIBUTES;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)sa;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)pa;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)smmu_bypass;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_master_sid(sc_ipc_t ipc, sc_rsrc_t resource, sc_rm_sid_t sid)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_MASTER_SID;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U16(&msg, 2U) = (uint16_t)sid;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_peripheral_permissions(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_rm_pt_t pt, sc_rm_perm_t perm)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_PERIPHERAL_PERMISSIONS;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)perm;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_bool_t sc_rm_is_resource_owned(sc_ipc_t ipc, sc_rsrc_t resource)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_RESOURCE_OWNED;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_bool_t)result;
|
||||
}
|
||||
|
||||
sc_bool_t sc_rm_is_resource_master(sc_ipc_t ipc, sc_rsrc_t resource)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_RESOURCE_MASTER;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_bool_t)result;
|
||||
}
|
||||
|
||||
sc_bool_t sc_rm_is_resource_peripheral(sc_ipc_t ipc, sc_rsrc_t resource)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_RESOURCE_PERIPHERAL;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_bool_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_get_resource_info(sc_ipc_t ipc, sc_rsrc_t resource,
|
||||
sc_rm_sid_t *sid)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_RESOURCE_INFO;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)resource;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (sid != NULL) {
|
||||
*sid = RPC_U16(&msg, 0U);
|
||||
}
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_memreg_alloc(sc_ipc_t ipc, sc_rm_mr_t *mr,
|
||||
sc_faddr_t addr_start, sc_faddr_t addr_end)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MEMREG_ALLOC;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr_start >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr_start;
|
||||
RPC_U32(&msg, 8U) = (uint32_t)(addr_end >> 32U);
|
||||
RPC_U32(&msg, 12U) = (uint32_t)addr_end;
|
||||
RPC_SIZE(&msg) = 5U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mr != NULL) {
|
||||
*mr = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_memreg_split(sc_ipc_t ipc, sc_rm_mr_t mr,
|
||||
sc_rm_mr_t *mr_ret, sc_faddr_t addr_start,
|
||||
sc_faddr_t addr_end)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MEMREG_SPLIT;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr_start >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr_start;
|
||||
RPC_U32(&msg, 8U) = (uint32_t)(addr_end >> 32U);
|
||||
RPC_U32(&msg, 12U) = (uint32_t)addr_end;
|
||||
RPC_U8(&msg, 16U) = (uint8_t)mr;
|
||||
RPC_SIZE(&msg) = 6U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mr_ret != NULL) {
|
||||
*mr_ret = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_memreg_free(sc_ipc_t ipc, sc_rm_mr_t mr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_MEMREG_FREE;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)mr;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_find_memreg(sc_ipc_t ipc, sc_rm_mr_t *mr,
|
||||
sc_faddr_t addr_start, sc_faddr_t addr_end)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_FIND_MEMREG;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(addr_start >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)addr_start;
|
||||
RPC_U32(&msg, 8U) = (uint32_t)(addr_end >> 32U);
|
||||
RPC_U32(&msg, 12U) = (uint32_t)addr_end;
|
||||
RPC_SIZE(&msg) = 5U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mr != NULL) {
|
||||
*mr = RPC_U8(&msg, 0U);
|
||||
}
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_assign_memreg(sc_ipc_t ipc, sc_rm_pt_t pt, sc_rm_mr_t mr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_ASSIGN_MEMREG;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)mr;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_memreg_permissions(sc_ipc_t ipc, sc_rm_mr_t mr,
|
||||
sc_rm_pt_t pt, sc_rm_perm_t perm)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_MEMREG_PERMISSIONS;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)mr;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)perm;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_bool_t sc_rm_is_memreg_owned(sc_ipc_t ipc, sc_rm_mr_t mr)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_MEMREG_OWNED;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)mr;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_bool_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_get_memreg_info(sc_ipc_t ipc, sc_rm_mr_t mr,
|
||||
sc_faddr_t *addr_start, sc_faddr_t *addr_end)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_GET_MEMREG_INFO;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)mr;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (addr_start != NULL) {
|
||||
*addr_start =
|
||||
((uint64_t) RPC_U32(&msg, 0U) << 32U) | RPC_U32(&msg, 4U);
|
||||
}
|
||||
|
||||
if (addr_end != NULL) {
|
||||
*addr_end =
|
||||
((uint64_t) RPC_U32(&msg, 8U) << 32U) | RPC_U32(&msg, 12U);
|
||||
}
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_assign_pad(sc_ipc_t ipc, sc_rm_pt_t pt, sc_pad_t pad)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_ASSIGN_PAD;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)pt;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_rm_set_pad_movable(sc_ipc_t ipc, sc_pad_t pad_fst,
|
||||
sc_pad_t pad_lst, sc_bool_t movable)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_SET_PAD_MOVABLE;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)pad_fst;
|
||||
RPC_U16(&msg, 2U) = (uint16_t)pad_lst;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)movable;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_bool_t sc_rm_is_pad_owned(sc_ipc_t ipc, sc_pad_t pad)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_IS_PAD_OWNED;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pad;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_bool_t)result;
|
||||
}
|
||||
|
||||
void sc_rm_dump(sc_ipc_t ipc)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_RM;
|
||||
RPC_FUNC(&msg) = (uint8_t)RM_FUNC_DUMP;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/**@}*/
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
/*
|
||||
* Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* Header file for the RM RPC implementation.
|
||||
*
|
||||
* @addtogroup RM_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifndef SCI_RM_RPC_H
|
||||
#define SCI_RM_RPC_H
|
||||
|
||||
/* Includes */
|
||||
|
||||
/* Defines */
|
||||
|
||||
/*!
|
||||
* @name Defines for RPC RM function calls
|
||||
*/
|
||||
/*@{*/
|
||||
#define RM_FUNC_UNKNOWN 0 /* Unknown function */
|
||||
#define RM_FUNC_PARTITION_ALLOC 1U /* Index for rm_partition_alloc() RPC call */
|
||||
#define RM_FUNC_SET_CONFIDENTIAL 31U /* Index for rm_set_confidential() RPC call */
|
||||
#define RM_FUNC_PARTITION_FREE 2U /* Index for rm_partition_free() RPC call */
|
||||
#define RM_FUNC_GET_DID 26U /* Index for rm_get_did() RPC call */
|
||||
#define RM_FUNC_PARTITION_STATIC 3U /* Index for rm_partition_static() RPC call */
|
||||
#define RM_FUNC_PARTITION_LOCK 4U /* Index for rm_partition_lock() RPC call */
|
||||
#define RM_FUNC_GET_PARTITION 5U /* Index for rm_get_partition() RPC call */
|
||||
#define RM_FUNC_SET_PARENT 6U /* Index for rm_set_parent() RPC call */
|
||||
#define RM_FUNC_MOVE_ALL 7U /* Index for rm_move_all() RPC call */
|
||||
#define RM_FUNC_ASSIGN_RESOURCE 8U /* Index for rm_assign_resource() RPC call */
|
||||
#define RM_FUNC_SET_RESOURCE_MOVABLE 9U /* Index for rm_set_resource_movable() RPC call */
|
||||
#define RM_FUNC_SET_SUBSYS_RSRC_MOVABLE 28U /* Index for rm_set_subsys_rsrc_movable() RPC call */
|
||||
#define RM_FUNC_SET_MASTER_ATTRIBUTES 10U /* Index for rm_set_master_attributes() RPC call */
|
||||
#define RM_FUNC_SET_MASTER_SID 11U /* Index for rm_set_master_sid() RPC call */
|
||||
#define RM_FUNC_SET_PERIPHERAL_PERMISSIONS 12U /* Index for rm_set_peripheral_permissions() RPC call */
|
||||
#define RM_FUNC_IS_RESOURCE_OWNED 13U /* Index for rm_is_resource_owned() RPC call */
|
||||
#define RM_FUNC_IS_RESOURCE_MASTER 14U /* Index for rm_is_resource_master() RPC call */
|
||||
#define RM_FUNC_IS_RESOURCE_PERIPHERAL 15U /* Index for rm_is_resource_peripheral() RPC call */
|
||||
#define RM_FUNC_GET_RESOURCE_INFO 16U /* Index for rm_get_resource_info() RPC call */
|
||||
#define RM_FUNC_MEMREG_ALLOC 17U /* Index for rm_memreg_alloc() RPC call */
|
||||
#define RM_FUNC_MEMREG_SPLIT 29U /* Index for rm_memreg_split() RPC call */
|
||||
#define RM_FUNC_MEMREG_FREE 18U /* Index for rm_memreg_free() RPC call */
|
||||
#define RM_FUNC_FIND_MEMREG 30U /* Index for rm_find_memreg() RPC call */
|
||||
#define RM_FUNC_ASSIGN_MEMREG 19U /* Index for rm_assign_memreg() RPC call */
|
||||
#define RM_FUNC_SET_MEMREG_PERMISSIONS 20U /* Index for rm_set_memreg_permissions() RPC call */
|
||||
#define RM_FUNC_IS_MEMREG_OWNED 21U /* Index for rm_is_memreg_owned() RPC call */
|
||||
#define RM_FUNC_GET_MEMREG_INFO 22U /* Index for rm_get_memreg_info() RPC call */
|
||||
#define RM_FUNC_ASSIGN_PAD 23U /* Index for rm_assign_pad() RPC call */
|
||||
#define RM_FUNC_SET_PAD_MOVABLE 24U /* Index for rm_set_pad_movable() RPC call */
|
||||
#define RM_FUNC_IS_PAD_OWNED 25U /* Index for rm_is_pad_owned() RPC call */
|
||||
#define RM_FUNC_DUMP 27U /* Index for rm_dump() RPC call */
|
||||
/*@}*/
|
||||
|
||||
/* Types */
|
||||
|
||||
/* Functions */
|
||||
|
||||
/*!
|
||||
* This function dispatches an incoming RM RPC request.
|
||||
*
|
||||
* @param[in] caller_pt caller partition
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void rm_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg);
|
||||
|
||||
/*!
|
||||
* This function translates and dispatches an RM RPC request.
|
||||
*
|
||||
* @param[in] ipc IPC handle
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void rm_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
|
||||
|
||||
#endif /* SCI_RM_RPC_H */
|
||||
|
||||
/**@}*/
|
||||
+69
@@ -0,0 +1,69 @@
|
||||
/*
|
||||
* Copyright (C) 2016 Freescale Semiconductor, Inc.
|
||||
* Copyright 2017-2019 NXP
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* Header file for the TIMER RPC implementation.
|
||||
*
|
||||
* @addtogroup TIMER_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifndef SC_TIMER_RPC_H
|
||||
#define SC_TIMER_RPC_H
|
||||
|
||||
/* Includes */
|
||||
|
||||
/* Defines */
|
||||
|
||||
/*!
|
||||
* @name Defines for RPC TIMER function calls
|
||||
*/
|
||||
/*@{*/
|
||||
#define TIMER_FUNC_UNKNOWN 0 /* Unknown function */
|
||||
#define TIMER_FUNC_SET_WDOG_TIMEOUT 1U /* Index for timer_set_wdog_timeout() RPC call */
|
||||
#define TIMER_FUNC_SET_WDOG_PRE_TIMEOUT 12U /* Index for timer_set_wdog_pre_timeout() RPC call */
|
||||
#define TIMER_FUNC_START_WDOG 2U /* Index for timer_start_wdog() RPC call */
|
||||
#define TIMER_FUNC_STOP_WDOG 3U /* Index for timer_stop_wdog() RPC call */
|
||||
#define TIMER_FUNC_PING_WDOG 4U /* Index for timer_ping_wdog() RPC call */
|
||||
#define TIMER_FUNC_GET_WDOG_STATUS 5U /* Index for timer_get_wdog_status() RPC call */
|
||||
#define TIMER_FUNC_PT_GET_WDOG_STATUS 13U /* Index for timer_pt_get_wdog_status() RPC call */
|
||||
#define TIMER_FUNC_SET_WDOG_ACTION 10U /* Index for timer_set_wdog_action() RPC call */
|
||||
#define TIMER_FUNC_SET_RTC_TIME 6U /* Index for timer_set_rtc_time() RPC call */
|
||||
#define TIMER_FUNC_GET_RTC_TIME 7U /* Index for timer_get_rtc_time() RPC call */
|
||||
#define TIMER_FUNC_GET_RTC_SEC1970 9U /* Index for timer_get_rtc_sec1970() RPC call */
|
||||
#define TIMER_FUNC_SET_RTC_ALARM 8U /* Index for timer_set_rtc_alarm() RPC call */
|
||||
#define TIMER_FUNC_SET_RTC_PERIODIC_ALARM 14U /* Index for timer_set_rtc_periodic_alarm() RPC call */
|
||||
#define TIMER_FUNC_CANCEL_RTC_ALARM 15U /* Index for timer_cancel_rtc_alarm() RPC call */
|
||||
#define TIMER_FUNC_SET_RTC_CALB 11U /* Index for timer_set_rtc_calb() RPC call */
|
||||
#define TIMER_FUNC_SET_SYSCTR_ALARM 16U /* Index for timer_set_sysctr_alarm() RPC call */
|
||||
#define TIMER_FUNC_SET_SYSCTR_PERIODIC_ALARM 17U /* Index for timer_set_sysctr_periodic_alarm() RPC call */
|
||||
#define TIMER_FUNC_CANCEL_SYSCTR_ALARM 18U /* Index for timer_cancel_sysctr_alarm() RPC call */
|
||||
/*@}*/
|
||||
|
||||
/* Types */
|
||||
|
||||
/* Functions */
|
||||
|
||||
/*!
|
||||
* This function dispatches an incoming TIMER RPC request.
|
||||
*
|
||||
* @param[in] caller_pt caller partition
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void timer_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg);
|
||||
|
||||
/*!
|
||||
* This function translates and dispatches an TIMER RPC request.
|
||||
*
|
||||
* @param[in] ipc IPC handle
|
||||
* @param[in] msg pointer to RPC message
|
||||
*/
|
||||
void timer_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
|
||||
|
||||
#endif /* SC_TIMER_RPC_H */
|
||||
|
||||
/**@}*/
|
||||
+396
@@ -0,0 +1,396 @@
|
||||
/*
|
||||
* Copyright (C) 2016 Freescale Semiconductor, Inc.
|
||||
* Copyright 2017-2019 NXP
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-3-Clause
|
||||
*/
|
||||
|
||||
/*!
|
||||
* File containing client-side RPC functions for the TIMER service. These
|
||||
* functions are ported to clients that communicate to the SC.
|
||||
*
|
||||
* @addtogroup TIMER_SVC
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* Includes */
|
||||
|
||||
#include <sci/sci_types.h>
|
||||
#include <sci/svc/rm/sci_rm_api.h>
|
||||
#include <sci/svc/timer/sci_timer_api.h>
|
||||
#include <sci/sci_rpc.h>
|
||||
#include <stdlib.h>
|
||||
#include "sci_timer_rpc.h"
|
||||
|
||||
/* Local Defines */
|
||||
|
||||
/* Local Types */
|
||||
|
||||
/* Local Functions */
|
||||
|
||||
sc_err_t sc_timer_set_wdog_timeout(sc_ipc_t ipc, sc_timer_wdog_time_t timeout)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_WDOG_TIMEOUT;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)timeout;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_wdog_pre_timeout(sc_ipc_t ipc,
|
||||
sc_timer_wdog_time_t pre_timeout)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_WDOG_PRE_TIMEOUT;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)pre_timeout;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_start_wdog(sc_ipc_t ipc, sc_bool_t lock)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_START_WDOG;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)lock;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_stop_wdog(sc_ipc_t ipc)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_STOP_WDOG;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_ping_wdog(sc_ipc_t ipc)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_PING_WDOG;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_get_wdog_status(sc_ipc_t ipc,
|
||||
sc_timer_wdog_time_t *timeout,
|
||||
sc_timer_wdog_time_t *max_timeout,
|
||||
sc_timer_wdog_time_t *remaining_time)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_GET_WDOG_STATUS;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (timeout != NULL)
|
||||
*timeout = RPC_U32(&msg, 0U);
|
||||
|
||||
if (max_timeout != NULL)
|
||||
*max_timeout = RPC_U32(&msg, 4U);
|
||||
|
||||
if (remaining_time != NULL)
|
||||
*remaining_time = RPC_U32(&msg, 8U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_pt_get_wdog_status(sc_ipc_t ipc, sc_rm_pt_t pt,
|
||||
sc_bool_t *enb,
|
||||
sc_timer_wdog_time_t *timeout,
|
||||
sc_timer_wdog_time_t *remaining_time)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_PT_GET_WDOG_STATUS;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (timeout != NULL)
|
||||
*timeout = RPC_U32(&msg, 0U);
|
||||
|
||||
if (remaining_time != NULL)
|
||||
*remaining_time = RPC_U32(&msg, 4U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (enb != NULL)
|
||||
*enb = RPC_U8(&msg, 8U);
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_wdog_action(sc_ipc_t ipc,
|
||||
sc_rm_pt_t pt, sc_timer_wdog_action_t action)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_WDOG_ACTION;
|
||||
RPC_U8(&msg, 0U) = (uint8_t)pt;
|
||||
RPC_U8(&msg, 1U) = (uint8_t)action;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_rtc_time(sc_ipc_t ipc, uint16_t year, uint8_t mon,
|
||||
uint8_t day, uint8_t hour, uint8_t min,
|
||||
uint8_t sec)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_RTC_TIME;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)year;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)mon;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)day;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)hour;
|
||||
RPC_U8(&msg, 5U) = (uint8_t)min;
|
||||
RPC_U8(&msg, 6U) = (uint8_t)sec;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_get_rtc_time(sc_ipc_t ipc, uint16_t *year, uint8_t *mon,
|
||||
uint8_t *day, uint8_t *hour, uint8_t *min,
|
||||
uint8_t *sec)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_GET_RTC_TIME;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (year != NULL)
|
||||
*year = RPC_U16(&msg, 0U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
if (mon != NULL)
|
||||
*mon = RPC_U8(&msg, 2U);
|
||||
|
||||
if (day != NULL)
|
||||
*day = RPC_U8(&msg, 3U);
|
||||
|
||||
if (hour != NULL)
|
||||
*hour = RPC_U8(&msg, 4U);
|
||||
|
||||
if (min != NULL)
|
||||
*min = RPC_U8(&msg, 5U);
|
||||
|
||||
if (sec != NULL)
|
||||
*sec = RPC_U8(&msg, 6U);
|
||||
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_get_rtc_sec1970(sc_ipc_t ipc, uint32_t *sec)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_GET_RTC_SEC1970;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
if (sec != NULL)
|
||||
*sec = RPC_U32(&msg, 0U);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_rtc_alarm(sc_ipc_t ipc, uint16_t year, uint8_t mon,
|
||||
uint8_t day, uint8_t hour, uint8_t min,
|
||||
uint8_t sec)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_RTC_ALARM;
|
||||
RPC_U16(&msg, 0U) = (uint16_t)year;
|
||||
RPC_U8(&msg, 2U) = (uint8_t)mon;
|
||||
RPC_U8(&msg, 3U) = (uint8_t)day;
|
||||
RPC_U8(&msg, 4U) = (uint8_t)hour;
|
||||
RPC_U8(&msg, 5U) = (uint8_t)min;
|
||||
RPC_U8(&msg, 6U) = (uint8_t)sec;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_rtc_periodic_alarm(sc_ipc_t ipc, uint32_t sec)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_RTC_PERIODIC_ALARM;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)sec;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_cancel_rtc_alarm(sc_ipc_t ipc)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_CANCEL_RTC_ALARM;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_rtc_calb(sc_ipc_t ipc, int8_t count)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_RTC_CALB;
|
||||
RPC_I8(&msg, 0U) = (int8_t) count;
|
||||
RPC_SIZE(&msg) = 2U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_sysctr_alarm(sc_ipc_t ipc, uint64_t ticks)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_SYSCTR_ALARM;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(ticks >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)ticks;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_set_sysctr_periodic_alarm(sc_ipc_t ipc, uint64_t ticks)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_SET_SYSCTR_PERIODIC_ALARM;
|
||||
RPC_U32(&msg, 0U) = (uint32_t)(ticks >> 32U);
|
||||
RPC_U32(&msg, 4U) = (uint32_t)ticks;
|
||||
RPC_SIZE(&msg) = 3U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
sc_err_t sc_timer_cancel_sysctr_alarm(sc_ipc_t ipc)
|
||||
{
|
||||
sc_rpc_msg_t msg;
|
||||
uint8_t result;
|
||||
|
||||
RPC_VER(&msg) = SC_RPC_VERSION;
|
||||
RPC_SVC(&msg) = (uint8_t)SC_RPC_SVC_TIMER;
|
||||
RPC_FUNC(&msg) = (uint8_t)TIMER_FUNC_CANCEL_SYSCTR_ALARM;
|
||||
RPC_SIZE(&msg) = 1U;
|
||||
|
||||
sc_call_rpc(ipc, &msg, SC_FALSE);
|
||||
|
||||
result = RPC_R8(&msg);
|
||||
return (sc_err_t)result;
|
||||
}
|
||||
|
||||
/**@}*/
|
||||
Reference in New Issue
Block a user