--- /dev/null
+obj-$(CONFIG_ARCH_FSL_IMX8QM) += mu/
+obj-$(CONFIG_ARCH_FSL_IMX8QM) += sc/
+obj-$(CONFIG_ARCH_FSL_IMX8QM) += rpmsg/
+obj-$(CONFIG_ARCH_FSL_IMX8QM) += pm-domains.o soc-imx8.o
--- /dev/null
+obj-y += mx8_mu.o
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include <linux/err.h>
+#include <linux/io.h>
+#include "mx8_mu.h"
+
+
+/*!
+ * This function enables specific RX full interrupt.
+ */
+void MU_EnableRxFullInt(void __iomem *base, uint32_t index)
+{
+ uint32_t reg = readl_relaxed(base + MU_ACR_OFFSET1);
+
+ reg &= ~(MU_CR_GIRn_MASK1 | MU_CR_NMI_MASK1);
+ reg |= ~MU_CR_RIE0_MASK1 >> index;
+ writel_relaxed(reg, base + MU_ACR_OFFSET1);
+}
+
+/*!
+ * This function enables specific general purpose interrupt.
+ */
+void MU_EnableGeneralInt(void __iomem *base, uint32_t index)
+{
+ uint32_t reg = readl_relaxed(base + MU_ACR_OFFSET1);
+
+ reg &= ~(MU_CR_GIRn_MASK1 | MU_CR_NMI_MASK1);
+ reg |= MU_CR_GIE0_MASK1 >> index;
+ writel_relaxed(reg, base + MU_ACR_OFFSET1);
+}
+
+/*
+ * Wait and send message to the other core.
+ */
+void MU_SendMessage(void __iomem *base, uint32_t regIndex, uint32_t msg)
+{
+ uint32_t mask = MU_SR_TE0_MASK1 >> regIndex;
+
+ /* Wait TX register to be empty. */
+ while (!(readl_relaxed(base + MU_ASR_OFFSET1) & mask))
+ ;
+ writel_relaxed(msg, base + MU_ATR0_OFFSET1 + (regIndex * 4));
+}
+
+
+/*
+ * Wait to receive message from the other core.
+ */
+void MU_ReceiveMsg(void __iomem *base, uint32_t regIndex, uint32_t *msg)
+{
+ uint32_t mask = MU_SR_RF0_MASK1 >> regIndex;
+
+ /* Wait RX register to be full. */
+ while (!(readl_relaxed(base + MU_ASR_OFFSET1) & mask))
+ ;
+ *msg = readl_relaxed(base + MU_ARR0_OFFSET1 + (regIndex * 4));
+}
+
+
+
+void MU_Init(void __iomem *base)
+{
+ uint32_t reg;
+
+ reg = readl_relaxed(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_NMI_MASK1 | MU_CR_Fn_MASK1);
+ writel_relaxed(reg, base + MU_ACR_OFFSET1);
+}
+
+/**@}*/
+
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#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 (0xF << 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 (1 << 31)
+
+#define MU_TR_COUNT 4
+#define MU_RR_COUNT 4
+
+
+void MU_Init(void __iomem *base);
+void MU_SendMessage(void __iomem *base, uint32_t regIndex, uint32_t msg);
+void MU_ReceiveMsg(void __iomem *base, uint32_t regIndex, uint32_t *msg);
+void MU_EnableGeneralInt(void __iomem *base, uint32_t index);
+void MU_EnableRxFullInt(void __iomem *base, uint32_t index);
+
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef PM_DOMAIN_IMX8_H
+#define PM_DOMAIN_IMX8_H
+
+#include <linux/pm_domain.h>
+#include <soc/imx8/sc/sci.h>
+
+#define DEFAULT_DEV_LATENCY_NS 250000
+
+struct platform_device;
+
+struct imx8_pm_domain {
+ const char *name;
+ struct generic_pm_domain pd;
+ struct dev_power_governor *gov;
+ int (*suspend)(void);
+ void (*resume)(void);
+ sc_rsrc_t rsrc_id;
+};
+
+static inline
+struct imx8_pm_domain *to_imx8_pd(struct generic_pm_domain *d)
+{
+ return container_of(d, struct imx8_pm_domain, pd);
+}
+
+struct pm_domain_device {
+ const char *domain_name;
+ struct platform_device *pdev;
+};
+
+#endif /* PM_DOMAIN_IMX8_H */
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/console.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/pm_clock.h>
+#include <linux/slab.h>
+
+#include <soc/imx8/sc/sci.h>
+
+#include "pm-domain-imx8.h"
+
+static sc_ipc_t pm_ipc_handle;
+
+static int imx8_pd_power(struct generic_pm_domain *domain, bool power_on)
+{
+ struct imx8_pm_domain *pd;
+ sc_err_t sci_err;
+
+ pd = container_of(domain, struct imx8_pm_domain, pd);
+
+ if (pd->rsrc_id == SC_R_LAST)
+ return 0;
+
+ sci_err = sc_pm_set_resource_power_mode(pm_ipc_handle, pd->rsrc_id,
+ (power_on) ? SC_PM_PW_MODE_ON : SC_PM_PW_MODE_OFF);
+
+ if (sci_err)
+ pr_err("Failed power operation on resource %d\n", pd->rsrc_id);
+
+ return 0;
+}
+
+static int imx8_pd_power_on(struct generic_pm_domain *domain)
+{
+ return imx8_pd_power(domain, true);
+}
+
+static int imx8_pd_power_off(struct generic_pm_domain *domain)
+{
+ return imx8_pd_power(domain, false);
+}
+
+static int __init imx8_add_pm_domains(struct device_node *parent,
+ struct generic_pm_domain *genpd_parent)
+{
+ struct device_node *np;
+
+ for_each_child_of_node(parent, np) {
+ struct imx8_pm_domain *imx8_pd;
+ sc_rsrc_t rsrc_id;
+
+ imx8_pd = kzalloc(sizeof(*imx8_pd), GFP_KERNEL);
+ if (!imx8_pd)
+ return -ENOMEM;
+
+ if (!of_property_read_string(np, "name", &imx8_pd->pd.name))
+ imx8_pd->name = imx8_pd->pd.name;
+
+ if (!of_property_read_u32(np, "reg", &rsrc_id))
+ imx8_pd->rsrc_id = rsrc_id;
+
+ imx8_pd->pd.power_off = imx8_pd_power_off;
+ imx8_pd->pd.power_on = imx8_pd_power_on;
+
+ pm_genpd_init(&imx8_pd->pd, NULL, true);
+
+ if (genpd_parent)
+ pm_genpd_add_subdomain(genpd_parent, &imx8_pd->pd);
+
+ of_genpd_add_provider_simple(np, &imx8_pd->pd);
+
+ imx8_add_pm_domains(np, &imx8_pd->pd);
+ }
+ return 0;
+}
+
+static int __init imx8_init_pm_domains(void)
+{
+ struct device_node *np;
+ sc_err_t sci_err;
+ sc_rsrc_t rsrc_id;
+ uint32_t mu_id;
+
+ /* skip pm domains for non-SCFW system */
+ if (!of_find_compatible_node(NULL, NULL, "nxp,imx8-pd"))
+ return 0;
+
+ pr_info("***** imx8_init_pm_domains *****\n");
+
+ for_each_compatible_node(np, NULL, "nxp,imx8-pd") {
+ struct imx8_pm_domain *imx8_pd;
+
+ imx8_pd = kzalloc(sizeof(struct imx8_pm_domain), GFP_KERNEL);
+ if (!imx8_pd) {
+ pr_err("%s: failed to allocate memory for domain\n",
+ __func__);
+ return -ENOMEM;
+ }
+ if (!of_property_read_string(np, "name", &imx8_pd->pd.name))
+ imx8_pd->name = imx8_pd->pd.name;
+
+ if (!of_property_read_u32(np, "reg", &rsrc_id))
+ imx8_pd->rsrc_id = rsrc_id;
+
+ if (imx8_pd->rsrc_id != SC_R_LAST) {
+ imx8_pd->pd.power_off = imx8_pd_power_off;
+ imx8_pd->pd.power_on = imx8_pd_power_on;
+ }
+ pm_genpd_init(&imx8_pd->pd, NULL, true);
+ of_genpd_add_provider_simple(np, &imx8_pd->pd);
+ imx8_add_pm_domains(np, &imx8_pd->pd);
+ }
+
+ sci_err = sc_ipc_getMuID(&mu_id);
+ if (sci_err != SC_ERR_NONE) {
+ pr_info("Cannot obtain MU ID\n");
+ return sci_err;
+ }
+
+ sci_err = sc_ipc_open(&pm_ipc_handle, mu_id);
+
+ return 0;
+}
+
+early_initcall(imx8_init_pm_domains);
--- /dev/null
+obj-y += imx_rpmsg.o
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
+#include <linux/of_reserved_mem.h>
+#include <linux/platform_device.h>
+#include <linux/rpmsg.h>
+#include <linux/slab.h>
+#include <linux/virtio.h>
+#include <linux/virtio_config.h>
+#include <linux/virtio_ids.h>
+#include <linux/virtio_ring.h>
+#include "../mu/mx8_mu.h"
+
+#define MU_ARR1_OFFSET 0x14
+#define MU_ASR 0x20
+
+static void __iomem *mu_base;
+static u32 m4_message;
+static struct delayed_work rpmsg_work;
+
+struct imx_mu_rpmsg_box {
+ const char *name;
+ struct blocking_notifier_head notifier;
+};
+
+static struct imx_mu_rpmsg_box mu_rpmsg_box = {
+ .name = "m4",
+};
+
+struct imx_rpmsg_vproc {
+ struct virtio_device vdev;
+ dma_addr_t vring[2];
+ char *rproc_name;
+ struct mutex lock;
+ struct notifier_block nb;
+ struct virtqueue *vq[2];
+ int base_vq_id;
+ int num_of_vqs;
+};
+
+/*
+ * For now, allocate 256 buffers of 512 bytes for each side. each buffer
+ * will then have 16B for the msg header and 496B for the payload.
+ * This will require a total space of 256KB for the buffers themselves, and
+ * 3 pages for every vring (the size of the vring depends on the number of
+ * buffers it supports).
+ */
+#define RPMSG_NUM_BUFS (512)
+#define RPMSG_BUF_SIZE (512)
+#define RPMSG_BUFS_SPACE (RPMSG_NUM_BUFS * RPMSG_BUF_SIZE)
+
+/*
+ * The alignment between the consumer and producer parts of the vring.
+ * Note: this is part of the "wire" protocol. If you change this, you need
+ * to update your BIOS image as well
+ */
+#define RPMSG_VRING_ALIGN (4096)
+
+/* With 256 buffers, our vring will occupy 3 pages */
+#define RPMSG_RING_SIZE ((DIV_ROUND_UP(vring_size(RPMSG_NUM_BUFS / 2, \
+ RPMSG_VRING_ALIGN), PAGE_SIZE)) * PAGE_SIZE)
+
+#define to_imx_rpdev(vd) container_of(vd, struct imx_rpmsg_vproc, vdev)
+
+struct imx_rpmsg_vq_info {
+ __u16 num; /* number of entries in the virtio_ring */
+ __u16 vq_id; /* a globaly unique index of this virtqueue */
+ void *addr; /* address where we mapped the virtio ring */
+ struct imx_rpmsg_vproc *rpdev;
+};
+
+static u64 imx_rpmsg_get_features(struct virtio_device *vdev)
+{
+ return 1 << VIRTIO_RPMSG_F_NS;
+}
+
+static int imx_rpmsg_finalize_features(struct virtio_device *vdev)
+{
+ /* Give virtio_ring a chance to accept features */
+ vring_transport_features(vdev);
+ return 0;
+}
+
+/* kick the remote processor, and let it know which virtqueue to poke at */
+static bool imx_rpmsg_notify(struct virtqueue *vq)
+{
+ unsigned int mu_rpmsg = 0;
+ struct imx_rpmsg_vq_info *rpvq = vq->priv;
+
+ mu_rpmsg = rpvq->vq_id << 16;
+ mutex_lock(&rpvq->rpdev->lock);
+ /* send the index of the triggered virtqueue as the mu payload */
+ MU_SendMessage(mu_base, 1, mu_rpmsg);
+ mutex_unlock(&rpvq->rpdev->lock);
+
+ return true;
+}
+
+static int imx_mu_rpmsg_callback(struct notifier_block *this,
+ unsigned long index, void *data)
+{
+ u32 mu_msg = (u64) data;
+ struct imx_rpmsg_vproc *rpdev;
+
+ rpdev = container_of(this, struct imx_rpmsg_vproc, nb);
+
+ pr_debug("%s mu_msg: 0x%x\n", __func__, mu_msg);
+
+ /* ignore vq indices which are clearly not for us */
+ mu_msg = mu_msg >> 16;
+ if (mu_msg < rpdev->base_vq_id)
+ pr_err("mu_msg: 0x%x is invalid\n", mu_msg);
+
+ mu_msg -= rpdev->base_vq_id;
+
+ /*
+ * Currently both PENDING_MSG and explicit-virtqueue-index
+ * messaging are supported.
+ * Whatever approach is taken, at this point 'mu_msg' contains
+ * the index of the vring which was just triggered.
+ */
+ if (mu_msg < rpdev->num_of_vqs)
+ vring_interrupt(mu_msg, rpdev->vq[mu_msg]);
+
+ return NOTIFY_DONE;
+}
+
+int imx_mu_rpmsg_register_nb(const char *name, struct notifier_block *nb)
+{
+ if ((name == NULL) || (nb == NULL))
+ return -EINVAL;
+
+ if (!strcmp(mu_rpmsg_box.name, name))
+ blocking_notifier_chain_register(&(mu_rpmsg_box.notifier), nb);
+ else
+ return -ENOENT;
+
+ return 0;
+}
+
+int imx_mu_rpmsg_unregister_nb(const char *name, struct notifier_block *nb)
+{
+ if ((name == NULL) || (nb == NULL))
+ return -EINVAL;
+
+ if (!strcmp(mu_rpmsg_box.name, name))
+ blocking_notifier_chain_unregister(&(mu_rpmsg_box.notifier),
+ nb);
+ else
+ return -ENOENT;
+
+ return 0;
+}
+
+static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
+ unsigned index,
+ void (*callback)(struct virtqueue *vq),
+ const char *name)
+{
+ struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
+ struct imx_rpmsg_vq_info *rpvq;
+ struct virtqueue *vq;
+ int err;
+
+ rpvq = kmalloc(sizeof(*rpvq), GFP_KERNEL);
+ if (!rpvq)
+ return ERR_PTR(-ENOMEM);
+
+ dma_alloc_from_coherent(vdev->dev.parent, 0x8000,
+ &rpdev->vring[index], &rpvq->addr);
+ if (!rpvq->addr) {
+ err = -ENOMEM;
+ goto free_rpvq;
+ }
+
+ pr_debug("vring%d: phys 0x%llx, virt 0x%p\n", index, rpdev->vring[index],
+ rpvq->addr);
+ vq = vring_new_virtqueue(index, RPMSG_NUM_BUFS / 2, RPMSG_VRING_ALIGN,
+ vdev, true, rpvq->addr, imx_rpmsg_notify, callback,
+ name);
+ if (!vq) {
+ pr_err("vring_new_virtqueue failed\n");
+ err = -ENOMEM;
+ goto unmap_vring;
+ }
+
+ rpdev->vq[index] = vq;
+ vq->priv = rpvq;
+ /* system-wide unique id for this virtqueue */
+ rpvq->vq_id = rpdev->base_vq_id + index;
+ rpvq->rpdev = rpdev;
+ mutex_init(&rpdev->lock);
+
+ return vq;
+
+unmap_vring:
+ /* iounmap normal memory, so make sparse happy */
+ iounmap((__force void __iomem *) rpvq->addr);
+free_rpvq:
+ kfree(rpvq);
+ return ERR_PTR(err);
+}
+
+static void imx_rpmsg_del_vqs(struct virtio_device *vdev)
+{
+ struct virtqueue *vq, *n;
+ struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
+
+ list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
+ struct imx_rpmsg_vq_info *rpvq = vq->priv;
+
+ iounmap(rpvq->addr);
+ vring_del_virtqueue(vq);
+ kfree(rpvq);
+ }
+
+ if (&rpdev->nb)
+ imx_mu_rpmsg_unregister_nb((const char *)rpdev->rproc_name,
+ &rpdev->nb);
+}
+
+static int imx_rpmsg_find_vqs(struct virtio_device *vdev, unsigned nvqs,
+ struct virtqueue *vqs[],
+ vq_callback_t *callbacks[],
+ const char * const names[])
+{
+ struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
+ int i, err;
+
+ /* we maintain two virtqueues per remote processor (for RX and TX) */
+ if (nvqs != 2)
+ return -EINVAL;
+
+ for (i = 0; i < nvqs; ++i) {
+ vqs[i] = rp_find_vq(vdev, i, callbacks[i], names[i]);
+ if (IS_ERR(vqs[i])) {
+ err = PTR_ERR(vqs[i]);
+ goto error;
+ }
+ }
+
+ rpdev->num_of_vqs = nvqs;
+
+ rpdev->nb.notifier_call = imx_mu_rpmsg_callback;
+ imx_mu_rpmsg_register_nb((const char *)rpdev->rproc_name, &rpdev->nb);
+
+ return 0;
+
+error:
+ imx_rpmsg_del_vqs(vdev);
+ return err;
+}
+
+static void imx_rpmsg_reset(struct virtio_device *vdev)
+{
+ dev_dbg(&vdev->dev, "reset !\n");
+}
+
+static u8 imx_rpmsg_get_status(struct virtio_device *vdev)
+{
+ return 0;
+}
+
+static void imx_rpmsg_set_status(struct virtio_device *vdev, u8 status)
+{
+ dev_dbg(&vdev->dev, "%s new status: %d\n", __func__, status);
+}
+
+static void imx_rpmsg_vproc_release(struct device *dev)
+{
+ /* this handler is provided so driver core doesn't yell at us */
+}
+
+static struct virtio_config_ops imx_rpmsg_config_ops = {
+ .get_features = imx_rpmsg_get_features,
+ .finalize_features = imx_rpmsg_finalize_features,
+ .find_vqs = imx_rpmsg_find_vqs,
+ .del_vqs = imx_rpmsg_del_vqs,
+ .reset = imx_rpmsg_reset,
+ .set_status = imx_rpmsg_set_status,
+ .get_status = imx_rpmsg_get_status,
+};
+
+static struct imx_rpmsg_vproc imx_rpmsg_vprocs[] = {
+ {
+ .vdev.id.device = VIRTIO_ID_RPMSG,
+ .vdev.config = &imx_rpmsg_config_ops,
+ .rproc_name = "m4",
+ .base_vq_id = 0,
+ },
+};
+
+static const struct of_device_id imx_rpmsg_dt_ids[] = {
+ { .compatible = "fsl,imx8dv-rpmsg", },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, imx_rpmsg_dt_ids);
+
+static void rpmsg_work_handler(struct work_struct *work)
+{
+ u64 val = m4_message;
+
+ blocking_notifier_call_chain(&(mu_rpmsg_box.notifier), 4, (void *)val);
+ m4_message = 0;
+}
+
+static irqreturn_t imx8_mu_rpmsg_isr(int irq, void *param)
+{
+ u32 irqs;
+
+ irqs = readl_relaxed(mu_base + MU_ASR);
+
+ /* RPMSG */
+ if (irqs & (1 << 26)) {
+ /* get message from receive buffer */
+ MU_ReceiveMsg(mu_base, 1, &m4_message);
+ schedule_delayed_work(&rpmsg_work, 0);
+ }
+
+ return IRQ_HANDLED;
+}
+
+static int imx_rpmsg_probe(struct platform_device *pdev)
+{
+ int i, ret = 0;
+ u32 irq, val;
+ struct device_node *np;
+
+ /* Initialize the mu unit used by rpmsg */
+ np = of_find_compatible_node(NULL, NULL, "fsl,imx8-mu-rpmsg");
+ if (!np)
+ pr_info("Cannot find MU-RPMSG entry in device tree\n");
+
+ /* Make check the MU is initialized by CM4_0 or not */
+ if (of_property_read_u32(np, "mu_is_run", &val) < 0)
+ return -ENODEV;
+
+ mu_base = of_iomap(np, 0);
+ WARN_ON(!mu_base);
+
+ irq = of_irq_get(np, 0);
+
+ ret = request_irq(irq, imx8_mu_rpmsg_isr, IRQF_EARLY_RESUME,
+ "imx8_mu_rpmsg_isr", &mu_rpmsg_box);
+ if (ret) {
+ pr_info("imx8_mu_init :request_irq failed %d, ret = %d\n",
+ irq, ret);
+ }
+
+ /* Init MU */
+ MU_Init(mu_base);
+ /* enable the bit26(RIE1) */
+ MU_EnableRxFullInt(mu_base, 1);
+
+ INIT_DELAYED_WORK(&rpmsg_work, rpmsg_work_handler);
+ BLOCKING_INIT_NOTIFIER_HEAD(&(mu_rpmsg_box.notifier));
+
+ pr_info("MU is ready for cross core communication!\n");
+
+ /* register the virtual processor */
+ np = pdev->dev.of_node;
+ for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
+ struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
+
+ if (!strcmp(rpdev->rproc_name, "m4")) {
+ ret = of_device_is_compatible(np, "fsl,imx8dv-rpmsg");
+ if (ret) {
+ of_reserved_mem_device_init(&pdev->dev);
+ } else {
+ /* hardcodes here now. */
+ rpdev->vring[0] = 0xFFFF0000;
+ rpdev->vring[1] = 0xFFFF8000;
+ }
+ } else {
+ break;
+ }
+
+ pr_debug("%s rpdev%d: vring0 0x%llx, vring1 0x%llx\n", __func__,
+ i, rpdev->vring[0], rpdev->vring[1]);
+
+ rpdev->vdev.dev.parent = &pdev->dev;
+ rpdev->vdev.dev.release = imx_rpmsg_vproc_release;
+
+ ret = register_virtio_device(&rpdev->vdev);
+ if (ret) {
+ pr_err("%s failed to register rpdev: %d\n",
+ __func__, ret);
+ break;
+ }
+ }
+
+ return ret;
+}
+
+static int imx_rpmsg_remove(struct platform_device *pdev)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
+ struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
+
+ unregister_virtio_device(&rpdev->vdev);
+ }
+ return 0;
+}
+
+static struct platform_driver imx_rpmsg_driver = {
+ .driver = {
+ .owner = THIS_MODULE,
+ .name = "imx-rpmsg",
+ .of_match_table = imx_rpmsg_dt_ids,
+ },
+ .probe = imx_rpmsg_probe,
+ .remove = imx_rpmsg_remove,
+};
+
+static int __init imx_rpmsg_init(void)
+{
+ int ret;
+
+ ret = platform_driver_register(&imx_rpmsg_driver);
+ if (ret)
+ pr_err("Unable to initialize rpmsg driver\n");
+ else
+ pr_info("imx rpmsg driver is registered.\n");
+
+ return ret;
+}
+
+static void __exit imx_rpmsg_exit(void)
+{
+ pr_info("imx rpmsg driver is unregistered.\n");
+ platform_driver_unregister(&imx_rpmsg_driver);
+}
+
+module_exit(imx_rpmsg_exit);
+module_init(imx_rpmsg_init);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("iMX remote processor messaging virtio device");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+obj-y += main/ipc.o
+obj-y += svc/misc/rpc_clnt.o
+obj-y += svc/pad/rpc_clnt.o
+obj-y += svc/pm/rpc_clnt.o
+obj-y += svc/rm/rpc_clnt.o
+obj-y += svc/timer/rpc_clnt.o
+obj-y += svc/irq/rpc_clnt.o
+
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/* Includes */
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/of.h>
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/of_fdt.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+
+#include <soc/imx8/sc/svc/irq/api.h>
+#include <soc/imx8/sc/ipc.h>
+#include <soc/imx8/sc/sci.h>
+
+#include "../../mu/mx8_mu.h"
+#include "rpc.h"
+
+/* Local Defines */
+#define MU_SIZE 0x10000
+
+/* Local Types */
+unsigned int scu_mu_id;
+static void __iomem *mu_base_virtaddr;
+static struct delayed_work scu_mu_work;
+static sc_ipc_t mu_ipcHandle;
+
+/* Local functions */
+
+/* Local variables */
+static uint32_t gIPCport;
+static bool scu_mu_init;
+
+DEFINE_MUTEX(scu_mu_mutex);
+
+static BLOCKING_NOTIFIER_HEAD(SCU_notifier_chain);
+
+EXPORT_SYMBOL(sc_pm_set_resource_power_mode);
+EXPORT_SYMBOL(sc_pm_get_resource_power_mode);
+EXPORT_SYMBOL(sc_pm_cpu_start);
+EXPORT_SYMBOL(sc_misc_set_control);
+EXPORT_SYMBOL(sc_pm_clock_enable);
+EXPORT_SYMBOL(sc_pm_set_clock_rate);
+EXPORT_SYMBOL(sc_pad_set_gp_28lpp);
+/*--------------------------------------------------------------------------*/
+/* RPC command/response */
+/*--------------------------------------------------------------------------*/
+void sc_call_rpc(sc_ipc_t handle, sc_rpc_msg_t *msg, bool no_resp)
+{
+ if (in_interrupt()) {
+ pr_warn("Cannot make SC IPC calls from an interrupt context\n");
+ dump_stack();
+ return;
+ }
+ mutex_lock(&scu_mu_mutex);
+
+ sc_ipc_write(handle, msg);
+ if (!no_resp)
+ sc_ipc_read(handle, msg);
+
+ mutex_unlock(&scu_mu_mutex);
+}
+EXPORT_SYMBOL(sc_call_rpc);
+
+/*--------------------------------------------------------------------------*/
+/* Get MU base address for specified IPC channel */
+/*--------------------------------------------------------------------------*/
+static uint32_t *sc_ipc_get_mu_base(uint32_t id)
+{
+ uint32_t *base;
+
+ /* Check parameters */
+ if (id >= SC_NUM_IPC)
+ base = NULL;
+ else
+ base = (uint32_t *) (mu_base_virtaddr + (id * MU_SIZE));
+
+ return base;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Get the MU ID used by Linux */
+/*--------------------------------------------------------------------------*/
+int sc_ipc_getMuID(uint32_t *mu_id)
+{
+ if (scu_mu_init) {
+ *mu_id = scu_mu_id;
+ return SC_ERR_NONE;
+ }
+ return SC_ERR_UNAVAILABLE;
+}
+
+EXPORT_SYMBOL(sc_ipc_getMuID);
+
+/*--------------------------------------------------------------------------*/
+/* Open an IPC channel */
+/*--------------------------------------------------------------------------*/
+sc_err_t sc_ipc_requestInt(sc_ipc_t *handle, uint32_t id)
+{
+ return SC_ERR_NONE;
+}
+
+/*--------------------------------------------------------------------------*/
+/* Open an IPC channel */
+/*--------------------------------------------------------------------------*/
+sc_err_t sc_ipc_open(sc_ipc_t *handle, uint32_t id)
+{
+ uint32_t *base;
+
+ mutex_lock(&scu_mu_mutex);
+
+ if (!scu_mu_init) {
+ mutex_unlock(&scu_mu_mutex);
+ return SC_ERR_UNAVAILABLE;
+ }
+ /* Get MU base associated with IPC channel */
+ base = sc_ipc_get_mu_base(id);
+
+ if (base == NULL) {
+ mutex_unlock(&scu_mu_mutex);
+ return SC_ERR_IPC;
+ }
+
+ *handle = (sc_ipc_t) task_pid_vnr(current);
+
+ mutex_unlock(&scu_mu_mutex);
+
+ return SC_ERR_NONE;
+}
+EXPORT_SYMBOL(sc_ipc_open);
+/*--------------------------------------------------------------------------*/
+/* Close an IPC channel */
+/*--------------------------------------------------------------------------*/
+void sc_ipc_close(sc_ipc_t handle)
+{
+ uint32_t *base;
+
+ mutex_lock(&scu_mu_mutex);
+
+ if (!scu_mu_init) {
+ mutex_unlock(&scu_mu_mutex);
+ return;
+ }
+
+ /* Get MU base associated with IPC channel */
+ base = sc_ipc_get_mu_base(gIPCport);
+
+ /* TBD ***** What needs to be done here? */
+ mutex_unlock(&scu_mu_mutex);
+}
+EXPORT_SYMBOL(sc_ipc_close);
+
+/*!
+ * This function reads a message from an IPC channel.
+ *
+ * @param[in] ipc id of channel read from
+ * @param[out] data pointer to message buffer to read
+ *
+ * This function will block if no message is available to be read.
+ */
+void sc_ipc_read(sc_ipc_t handle, void *data)
+{
+ uint32_t *base;
+ uint8_t count = 0;
+ sc_rpc_msg_t *msg = (sc_rpc_msg_t *) data;
+
+ /* Get MU base associated with IPC channel */
+ base = sc_ipc_get_mu_base(gIPCport);
+
+ if ((base == NULL) || (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.d32[count - 1]));
+ count++;
+ }
+}
+
+/*!
+ * This function writes a message to an IPC channel.
+ *
+ * @param[in] ipc id of channel to write to
+ * @param[in] data pointer to message buffer to write
+ *
+ * This function will block if the outgoing buffer is full.
+ */
+void sc_ipc_write(sc_ipc_t handle, void *data)
+{
+ uint32_t *base;
+ uint8_t count = 0;
+ sc_rpc_msg_t *msg = (sc_rpc_msg_t *) data;
+
+ /* Get MU base associated with IPC channel */
+ base = sc_ipc_get_mu_base(gIPCport);
+
+ if ((base == NULL) || (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.d32[count - 1]);
+ count++;
+ }
+}
+
+int register_scu_notifier(struct notifier_block *nb)
+{
+ return blocking_notifier_chain_register(&SCU_notifier_chain, nb);
+}
+
+EXPORT_SYMBOL(register_scu_notifier);
+
+int unregister_scu_notifier(struct notifier_block *nb)
+{
+ return blocking_notifier_chain_unregister(&SCU_notifier_chain, nb);
+}
+
+EXPORT_SYMBOL(unregister_scu_notifier);
+
+static int SCU_notifier_call_chain(unsigned long val)
+{
+ return (blocking_notifier_call_chain(&SCU_notifier_chain, val, NULL) ==
+ NOTIFY_BAD) ? -EINVAL : 0;
+}
+
+static void scu_mu_work_handler(struct work_struct *work)
+{
+ uint32_t irq_status;
+ sc_err_t sciErr;
+
+ /* Figure out what caused the interrupt. */
+ sciErr = sc_irq_status(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_TEMP,
+ &irq_status);
+
+ if (irq_status & (SC_IRQ_TEMP_PMIC0_HIGH | SC_IRQ_TEMP_PMIC1_HIGH))
+ SCU_notifier_call_chain(irq_status);
+
+ sciErr = sc_irq_status(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_RTC,
+ &irq_status);
+
+ if (irq_status & SC_IRQ_RTC)
+ SCU_notifier_call_chain(irq_status);
+}
+
+static irqreturn_t imx8_scu_mu_isr(int irq, void *param)
+{
+ u32 irqs;
+
+ irqs = (readl_relaxed(mu_base_virtaddr + 0x20) & (0xf << 28));
+ if (irqs) {
+ /* Clear the General Interrupt */
+ writel_relaxed(irqs, mu_base_virtaddr + 0x20);
+ /* Setup a bottom-half to handle the irq work. */
+ schedule_delayed_work(&scu_mu_work, 0);
+ }
+ return IRQ_HANDLED;
+}
+
+/*Initialization of the MU code. */
+int __init imx8_mu_init(void)
+{
+ struct device_node *np;
+ u32 irq;
+ int err;
+ sc_err_t sciErr;
+
+ /*
+ * Get the address of MU to be used for communication with the SCU
+ */
+ np = of_find_compatible_node(NULL, NULL, "fsl,imx8-mu");
+ if (!np) {
+ pr_info("Cannot find MU entry in device tree\n");
+ return 0;
+ }
+ mu_base_virtaddr = of_iomap(np, 0);
+ WARN_ON(!mu_base_virtaddr);
+
+ err = of_property_read_u32_index(np, "fsl,scu_ap_mu_id", 0, &scu_mu_id);
+ if (err)
+ pr_info("imx8_mu_init: Cannot get mu_id err = %d\n", err);
+
+ irq = of_irq_get(np, 0);
+
+ err = request_irq(irq, imx8_scu_mu_isr,
+ IRQF_EARLY_RESUME, "imx8_mu_isr", NULL);
+
+ if (err) {
+ pr_info("imx8_mu_init :request_irq failed %d, err = %d\n", irq,
+ err);
+ }
+
+ if (!scu_mu_init) {
+ uint32_t i;
+
+ INIT_DELAYED_WORK(&scu_mu_work, scu_mu_work_handler);
+
+ /* Init MU */
+ MU_Init(mu_base_virtaddr);
+
+#if 1
+ /* Enable all RX interrupts */
+ for (i = 0; i < MU_RR_COUNT; i++)
+ MU_EnableGeneralInt(mu_base_virtaddr, i);
+#endif
+ gIPCport = scu_mu_id;
+ scu_mu_init = true;
+ }
+
+ sciErr = sc_ipc_open(&mu_ipcHandle, scu_mu_id);
+ if (sciErr != SC_ERR_NONE) {
+ pr_info("Cannot open MU channel to SCU\n");
+ return sciErr;
+ };
+
+ /* Request for the high temp interrupt. */
+ sciErr = sc_irq_enable(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_TEMP,
+ SC_IRQ_TEMP_PMIC0_HIGH, true);
+
+ if (sciErr)
+ pr_info("Cannot request PMIC0_TEMP interrupt\n");
+
+ /* Request for the high temp interrupt. */
+ sciErr = sc_irq_enable(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_TEMP,
+ SC_IRQ_TEMP_PMIC1_HIGH, true);
+
+ if (sciErr)
+ pr_info("Cannot request PMIC1_TEMP interrupt\n");
+
+ /* Request for the rtc alarm interrupt. */
+ sciErr = sc_irq_enable(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_RTC,
+ SC_IRQ_RTC, true);
+
+ if (sciErr)
+ pr_info("Cannot request ALARM_RTC interrupt\n");
+
+ pr_info("*****Initialized MU\n");
+ return scu_mu_id;
+}
+
+early_initcall(imx8_mu_init);
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * Header file for the RPC implementation.
+ */
+
+#ifndef _SC_RPC_H
+#define _SC_RPC_H
+
+/* Includes */
+
+#include <soc/imx8/sc/types.h>
+#include <soc/imx8/sc/ipc.h>
+
+/* Defines */
+
+#define SC_RPC_VERSION 1
+
+#define SC_RPC_MAX_MSG 8
+
+#define RPC_VER(MSG) ((MSG)->version)
+#define RPC_SIZE(MSG) ((MSG)->size)
+#define RPC_SVC(MSG) ((MSG)->svc)
+#define RPC_FUNC(MSG) ((MSG)->func)
+#define RPC_R8(MSG) ((MSG)->func)
+#define RPC_D32(MSG, IDX) ((MSG)->DATA.d32[IDX / 4])
+#define RPC_F32(MSG, IDX) ((MSG)->DATA.f32[IDX / 4])
+#define RPC_D16(MSG, IDX) ((MSG)->DATA.d16[IDX / 2])
+#define RPC_D8(MSG, IDX) ((MSG)->DATA.d8[IDX])
+
+/* Types */
+
+typedef enum sc_rpc_svc_e {
+ SC_RPC_SVC_UNKNOWN = 0,
+ SC_RPC_SVC_RETURN = 1,
+ SC_RPC_SVC_PM = 2,
+ SC_RPC_SVC_RM = 3,
+ SC_RPC_SVC_TIMER = 5,
+ SC_RPC_SVC_PAD = 6,
+ SC_RPC_SVC_MISC = 7,
+ SC_RPC_SVC_IRQ = 8,
+ SC_RPC_SVC_ABORT = 9
+} sc_rpc_svc_t;
+
+typedef struct sc_rpc_msg_s {
+ uint8_t version;
+ uint8_t size;
+ uint8_t svc;
+ uint8_t func;
+ union {
+ uint32_t d32[(SC_RPC_MAX_MSG - 1)];
+ uint16_t d16[(SC_RPC_MAX_MSG - 1) * 2];
+ uint8_t d8[(SC_RPC_MAX_MSG - 1) * 4];
+ } DATA;
+} sc_rpc_msg_t;
+
+typedef enum sc_rpc_async_state_e {
+ SC_RPC_ASYNC_STATE_RD_START = 0,
+ SC_RPC_ASYNC_STATE_RD_ACTIVE = 1,
+ SC_RPC_ASYNC_STATE_RD_DONE = 2,
+ SC_RPC_ASYNC_STATE_WR_START = 3,
+ SC_RPC_ASYNC_STATE_WR_ACTIVE = 4,
+ SC_RPC_ASYNC_STATE_WR_DONE = 5,
+} sc_rpc_async_state_t;
+
+typedef struct sc_rpc_async_msg_s {
+ sc_rpc_async_state_t state;
+ uint8_t wordIdx;
+ sc_rpc_msg_t msg;
+ uint32_t timeStamp;
+} sc_rpc_async_msg_t;
+
+/* Functions */
+
+/*!
+ * This is an internal function to send an RPC message over an IPC
+ * channel. It is called by client-side SCFW API function shims.
+ *
+ * @param[in] ipc IPC handle
+ * @param[in,out] msg handle to a message
+ * @param[in] no_resp response flag
+ *
+ * If \a no_resp is false then this function waits for a response
+ * and returns the result in \a msg.
+ */
+void sc_call_rpc(sc_ipc_t ipc, sc_rpc_msg_t *msg, bool no_resp);
+
+/*!
+ * This is an internal function to dispath an RPC call that has
+ * arrived via IPC over an MU. It is called by server-side SCFW.
+ *
+ * @param[in] mu MU message arrived on
+ * @param[in,out] msg handle to a message
+ *
+ * The function result is returned in \a msg.
+ */
+void sc_rpc_dispatch(sc_rsrc_t mu, sc_rpc_msg_t *msg);
+
+/*!
+ * This function translates an RPC message and forwards on to the
+ * normal RPC API. It is used only by hypervisors.
+ *
+ * @param[in] ipc IPC handle
+ * @param[in,out] msg handle to a message
+ *
+ * This function decodes a message, calls macros to translate the
+ * resources, pins, addresses, partitions, memory regions, etc. and
+ * then forwards on to the hypervisors SCFW API.Return results are
+ * translated back abd placed back into the message to be returned
+ * to the original API.
+ */
+void sc_rpc_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
+
+#endif /* _SC_RPC_H */
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * Header file for the IRQ RPC implementation.
+ *
+ * @addtogroup IRQ_SVC
+ * @{
+ */
+
+#ifndef _SC_IRQ_RPC_H
+#define _SC_IRQ_RPC_H
+
+/* Includes */
+
+/* Defines */
+
+/* Types */
+
+/*!
+ * This type is used to indicate RPC IRQ function calls.
+ */
+typedef enum irq_func_e {
+ IRQ_FUNC_UNKNOWN, /* Unknown function */
+ IRQ_FUNC_ENABLE, /* Index for irq_enable() RPC call */
+ IRQ_FUNC_STATUS, /* Index for irq_status() RPC call */
+} irq_func_t;
+
+/* Functions */
+
+/*!
+ * This function dispatches an incoming IRQ RPC request.
+ *
+ * @param[in] caller_pt caller partition
+ * @param[in] msg pointer to RPC message
+ */
+void irq_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg);
+
+/*!
+ * This function translates and dispatches an IRQ RPC request.
+ *
+ * @param[in] ipc IPC handle
+ * @param[in] msg pointer to RPC message
+ */
+void irq_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
+
+#endif /* _SC_IRQ_RPC_H */
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * File containing client-side RPC functions for the IRQ service. These
+ * function are ported to clients that communicate to the SC.
+ *
+ * @addtogroup IRQ_SVC
+ * @{
+ */
+
+/* Includes */
+
+#include <soc/imx8/sc/types.h>
+#include <soc/imx8/sc/svc/rm/api.h>
+#include <soc/imx8/sc/svc/irq/api.h>
+#include "../../main/rpc.h"
+#include "rpc.h"
+
+/* Local Defines */
+
+/* Local Types */
+
+/* Local Functions */
+
+sc_err_t sc_irq_enable(sc_ipc_t ipc, sc_rsrc_t resource,
+ sc_irq_group_t group, uint32_t mask, bool enable)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_IRQ;
+ RPC_FUNC(&msg) = IRQ_FUNC_ENABLE;
+ RPC_D32(&msg, 0) = mask;
+ RPC_D16(&msg, 4) = resource;
+ RPC_D8(&msg, 6) = group;
+ RPC_D8(&msg, 7) = enable;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_irq_status(sc_ipc_t ipc, sc_rsrc_t resource,
+ sc_irq_group_t group, uint32_t *status)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_IRQ;
+ RPC_FUNC(&msg) = IRQ_FUNC_STATUS;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = group;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (status != NULL)
+ *status = RPC_D32(&msg, 0);
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * Header file for the MISC RPC implementation.
+ *
+ * @addtogroup MISC_SVC
+ * @{
+ */
+
+#ifndef _SC_MISC_RPC_H
+#define _SC_MISC_RPC_H
+
+/* Includes */
+
+/* Defines */
+
+/* Types */
+
+/*!
+ * This type is used to indicate RPC MISC function calls.
+ */
+typedef enum misc_func_e {
+ MISC_FUNC_UNKNOWN, /* Unknown function */
+ MISC_FUNC_SET_CONTROL, /* Index for misc_set_control() RPC call */
+ MISC_FUNC_GET_CONTROL, /* Index for misc_get_control() RPC call */
+ MISC_FUNC_SET_ARI, /* Index for misc_set_ari() RPC call */
+ MISC_FUNC_SET_MAX_DMA_GROUP, /* Index for misc_set_max_dma_group() RPC call */
+ MISC_FUNC_SET_DMA_GROUP, /* Index for misc_set_dma_group() RPC call */
+ MISC_FUNC_WAVEFORM_CAPTURE, /* Index for misc_waveform_capture() RPC call */
+ MISC_FUNC_BOOT_STATUS, /* Index for misc_boot_status() RPC call */
+ MISC_FUNC_SECO_IMAGE_LOAD, /* Index for misc_seco_image_load() RPC call */
+ MISC_FUNC_SECO_AUTHENTICATE, /* Index for misc_seco_authenticate() RPC call */
+} misc_func_t;
+
+/* 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 */
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * File containing client-side RPC functions for the MISC service. These
+ * function are ported to clients that communicate to the SC.
+ *
+ * @addtogroup MISC_SVC
+ * @{
+ */
+
+/* Includes */
+
+#include <soc/imx8/sc/types.h>
+#include <soc/imx8/sc/svc/rm/api.h>
+#include <soc/imx8/sc/svc/misc/api.h>
+#include "../../main/rpc.h"
+#include "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) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_SET_CONTROL;
+ RPC_D32(&msg, 0) = ctrl;
+ RPC_D32(&msg, 4) = val;
+ RPC_D16(&msg, 8) = resource;
+ RPC_SIZE(&msg) = 4;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_GET_CONTROL;
+ RPC_D32(&msg, 0) = ctrl;
+ RPC_D16(&msg, 4) = resource;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (val != NULL)
+ *val = RPC_D32(&msg, 0);
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_misc_set_ari(sc_ipc_t ipc, sc_rsrc_t resource,
+ sc_rsrc_t resource_mst, uint16_t ari, bool enable)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_SET_ARI;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D16(&msg, 2) = resource_mst;
+ RPC_D16(&msg, 4) = ari;
+ RPC_D8(&msg, 6) = enable;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ 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) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_SET_MAX_DMA_GROUP;
+ RPC_D8(&msg, 0) = pt;
+ RPC_D8(&msg, 1) = max;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_SET_DMA_GROUP;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = group;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_misc_waveform_capture(sc_ipc_t ipc, bool enable)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_WAVEFORM_CAPTURE;
+ RPC_D8(&msg, 0) = enable;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_BOOT_STATUS;
+ RPC_D8(&msg, 0) = status;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, true);
+}
+
+sc_err_t sc_misc_seco_image_load(sc_ipc_t ipc, uint32_t addr_src,
+ uint32_t addr_dst, uint32_t len, bool fw)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_SECO_IMAGE_LOAD;
+ RPC_D32(&msg, 0) = addr_src;
+ RPC_D32(&msg, 4) = addr_dst;
+ RPC_D32(&msg, 8) = len;
+ RPC_D8(&msg, 12) = fw;
+ RPC_SIZE(&msg) = 5;
+
+ sc_call_rpc(ipc, &msg, 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,
+ uint32_t addr_meta)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_MISC;
+ RPC_FUNC(&msg) = MISC_FUNC_SECO_AUTHENTICATE;
+ RPC_D32(&msg, 0) = addr_meta;
+ RPC_D8(&msg, 4) = cmd;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * Header file for the PAD RPC implementation.
+ *
+ * @addtogroup PAD_SVC
+ * @{
+ */
+
+#ifndef _SC_PAD_RPC_H
+#define _SC_PAD_RPC_H
+
+/* Includes */
+
+/* Defines */
+
+/* Types */
+
+/*!
+ * This type is used to indicate RPC PAD function calls.
+ */
+typedef enum pad_func_e {
+ PAD_FUNC_UNKNOWN, /* Unknown function */
+ PAD_FUNC_SET_MUX, /* Index for pad_set_mux() RPC call */
+ PAD_FUNC_SET_GP, /* Index for pad_set_gp() RPC call */
+ PAD_FUNC_SET_GP_28LPP, /* Index for pad_set_gp_28lpp() RPC call */
+ PAD_FUNC_SET_WAKEUP, /* Index for pad_set_wakeup() RPC call */
+ PAD_FUNC_SET_ALL, /* Index for pad_set_all() RPC call */
+ PAD_FUNC_GET_MUX, /* Index for pad_get_mux() RPC call */
+ PAD_FUNC_GET_GP, /* Index for pad_get_gp() RPC call */
+ PAD_FUNC_GET_GP_28LPP, /* Index for pad_get_gp_28lpp() RPC call */
+ PAD_FUNC_GET_WAKEUP, /* Index for pad_get_wakeup() RPC call */
+ PAD_FUNC_GET_ALL, /* Index for pad_get_all() RPC call */
+ PAD_FUNC_SET_GP_28FDSOI, /* Index for pad_set_gp_28fdsoi() RPC call */
+ PAD_FUNC_GET_GP_28FDSOI, /* Index for pad_get_gp_28fdsoi() RPC call */
+ PAD_FUNC_SET_GP_28FDSOI_COMP, /* Index for pad_set_gp_28fdsoi_comp() RPC call */
+ PAD_FUNC_GET_GP_28FDSOI_COMP, /* Index for pad_get_gp_28fdsoi_comp() RPC call */
+ PAD_FUNC_SET, /* Index for pad_set() RPC call */
+ PAD_FUNC_GET, /* Index for pad_get() RPC call */
+} pad_func_t;
+
+/* 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 /* _SC_PAD_RPC_H */
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * File containing client-side RPC functions for the PAD service. These
+ * function are ported to clients that communicate to the SC.
+ *
+ * @addtogroup PAD_SVC
+ * @{
+ */
+
+/* Includes */
+
+#include <soc/imx8/sc/types.h>
+#include <soc/imx8/sc/svc/rm/api.h>
+#include <soc/imx8/sc/svc/pad/api.h>
+#include "../../main/rpc.h"
+#include "rpc.h"
+
+/* Local Defines */
+
+/* Local Types */
+
+/* Local Functions */
+
+sc_err_t sc_pad_set_mux(sc_ipc_t ipc, sc_pin_t pin,
+ 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) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET_MUX;
+ RPC_D16(&msg, 0) = pin;
+ RPC_D8(&msg, 2) = mux;
+ RPC_D8(&msg, 3) = config;
+ RPC_D8(&msg, 4) = iso;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_set_gp(sc_ipc_t ipc, sc_pin_t pin, uint32_t ctrl)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET_GP;
+ RPC_D32(&msg, 0) = ctrl;
+ RPC_D16(&msg, 4) = pin;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_set_gp_28lpp(sc_ipc_t ipc, sc_pin_t pin,
+ sc_pad_28lpp_dse_t dse, bool sre, bool hys,
+ bool pe, sc_pad_28lpp_ps_t ps)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET_GP_28LPP;
+ RPC_D16(&msg, 0) = pin;
+ RPC_D8(&msg, 2) = dse;
+ RPC_D8(&msg, 3) = ps;
+ RPC_D8(&msg, 4) = sre;
+ RPC_D8(&msg, 5) = hys;
+ RPC_D8(&msg, 6) = pe;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_set_wakeup(sc_ipc_t ipc, sc_pin_t pin, sc_pad_wakeup_t wakeup)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET_WAKEUP;
+ RPC_D16(&msg, 0) = pin;
+ RPC_D8(&msg, 2) = wakeup;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_set_all(sc_ipc_t ipc, sc_pin_t pin, 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) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET_ALL;
+ RPC_D32(&msg, 0) = ctrl;
+ RPC_D16(&msg, 4) = pin;
+ RPC_D8(&msg, 6) = mux;
+ RPC_D8(&msg, 7) = config;
+ RPC_D8(&msg, 8) = iso;
+ RPC_D8(&msg, 9) = wakeup;
+ RPC_SIZE(&msg) = 4;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get_mux(sc_ipc_t ipc, sc_pin_t pin,
+ 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) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET_MUX;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (mux != NULL)
+ *mux = RPC_D8(&msg, 0);
+ if (config != NULL)
+ *config = RPC_D8(&msg, 1);
+ if (iso != NULL)
+ *iso = RPC_D8(&msg, 2);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get_gp(sc_ipc_t ipc, sc_pin_t pin, uint32_t *ctrl)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET_GP;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (ctrl != NULL)
+ *ctrl = RPC_D32(&msg, 0);
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get_gp_28lpp(sc_ipc_t ipc, sc_pin_t pin,
+ sc_pad_28lpp_dse_t *dse, bool *sre, bool *hys,
+ bool *pe, sc_pad_28lpp_ps_t *ps)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET_GP_28LPP;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (dse != NULL)
+ *dse = RPC_D8(&msg, 0);
+ if (ps != NULL)
+ *ps = RPC_D8(&msg, 1);
+ if (sre != NULL)
+ *sre = RPC_D8(&msg, 2);
+ if (hys != NULL)
+ *hys = RPC_D8(&msg, 3);
+ if (pe != NULL)
+ *pe = RPC_D8(&msg, 4);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get_wakeup(sc_ipc_t ipc, sc_pin_t pin, sc_pad_wakeup_t *wakeup)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET_WAKEUP;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (wakeup != NULL)
+ *wakeup = RPC_D8(&msg, 0);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get_all(sc_ipc_t ipc, sc_pin_t pin, 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) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET_ALL;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (ctrl != NULL)
+ *ctrl = RPC_D32(&msg, 0);
+ result = RPC_R8(&msg);
+ if (mux != NULL)
+ *mux = RPC_D8(&msg, 4);
+ if (config != NULL)
+ *config = RPC_D8(&msg, 5);
+ if (iso != NULL)
+ *iso = RPC_D8(&msg, 6);
+ if (wakeup != NULL)
+ *wakeup = RPC_D8(&msg, 7);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_set_gp_28fdsoi(sc_ipc_t ipc, sc_pin_t pin,
+ 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) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET_GP_28FDSOI;
+ RPC_D16(&msg, 0) = pin;
+ RPC_D8(&msg, 2) = dse;
+ RPC_D8(&msg, 3) = ps;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get_gp_28fdsoi(sc_ipc_t ipc, sc_pin_t pin,
+ 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) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET_GP_28FDSOI;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (dse != NULL)
+ *dse = RPC_D8(&msg, 0);
+ if (ps != NULL)
+ *ps = RPC_D8(&msg, 1);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_set_gp_28fdsoi_comp(sc_ipc_t ipc, sc_pin_t pin,
+ uint8_t compen, bool fastfrz,
+ uint8_t rasrcp, uint8_t rasrcn,
+ bool nasrc_sel)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET_GP_28FDSOI_COMP;
+ RPC_D16(&msg, 0) = pin;
+ RPC_D8(&msg, 2) = compen;
+ RPC_D8(&msg, 3) = rasrcp;
+ RPC_D8(&msg, 4) = rasrcn;
+ RPC_D8(&msg, 5) = fastfrz;
+ RPC_D8(&msg, 6) = nasrc_sel;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get_gp_28fdsoi_comp(sc_ipc_t ipc, sc_pin_t pin,
+ uint8_t *compen, bool *fastfrz,
+ uint8_t *rasrcp, uint8_t *rasrcn,
+ bool *nasrc_sel, bool *compok,
+ uint8_t *nasrc)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET_GP_28FDSOI_COMP;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (compen != NULL)
+ *compen = RPC_D8(&msg, 0);
+ if (rasrcp != NULL)
+ *rasrcp = RPC_D8(&msg, 1);
+ if (rasrcn != NULL)
+ *rasrcn = RPC_D8(&msg, 2);
+ if (nasrc != NULL)
+ *nasrc = RPC_D8(&msg, 3);
+ if (fastfrz != NULL)
+ *fastfrz = RPC_D8(&msg, 4);
+ if (nasrc_sel != NULL)
+ *nasrc_sel = RPC_D8(&msg, 5);
+ if (compok != NULL)
+ *compok = RPC_D8(&msg, 6);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_set(sc_ipc_t ipc, sc_pin_t pin, uint32_t val)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_SET;
+ RPC_D32(&msg, 0) = val;
+ RPC_D16(&msg, 4) = pin;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pad_get(sc_ipc_t ipc, sc_pin_t pin, uint32_t *val)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PAD;
+ RPC_FUNC(&msg) = PAD_FUNC_GET;
+ RPC_D16(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (val != NULL)
+ *val = RPC_D32(&msg, 0);
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * Header file for the PM RPC implementation.
+ *
+ * @addtogroup PM_SVC
+ * @{
+ */
+
+#ifndef _SC_PM_RPC_H
+#define _SC_PM_RPC_H
+
+/* Includes */
+
+/* Defines */
+
+/* Types */
+
+/*!
+ * This type is used to indicate RPC PM function calls.
+ */
+typedef enum pm_func_e {
+ PM_FUNC_UNKNOWN, /* Unknown function */
+ PM_FUNC_SET_SYS_POWER_MODE, /* Index for pm_set_sys_power_mode() RPC call */
+ PM_FUNC_GET_SYS_POWER_MODE, /* Index for pm_get_sys_power_mode() RPC call */
+ PM_FUNC_SET_RESOURCE_POWER_MODE, /* Index for pm_set_resource_power_mode() RPC call */
+ PM_FUNC_GET_RESOURCE_POWER_MODE, /* Index for pm_get_resource_power_mode() RPC call */
+ PM_FUNC_SET_CLOCK_RATE, /* Index for pm_set_clock_rate() RPC call */
+ PM_FUNC_GET_CLOCK_RATE, /* Index for pm_get_clock_rate() RPC call */
+ PM_FUNC_CLOCK_ENABLE, /* Index for pm_clock_enable() RPC call */
+ PM_FUNC_BOOT, /* Index for pm_boot() RPC call */
+ PM_FUNC_REBOOT, /* Index for pm_reboot() RPC call */
+ PM_FUNC_RESET_REASON, /* Index for pm_reset_reason() RPC call */
+ PM_FUNC_CPU_START, /* Index for pm_cpu_start() RPC call */
+ PM_FUNC_REBOOT_PARTITION, /* Index for pm_reboot_partition() RPC call */
+ PM_FUNC_RESET, /* Index for pm_reset() RPC call */
+} pm_func_t;
+
+/* 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 /* _SC_PM_RPC_H */
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * File containing client-side RPC functions for the PM service. These
+ * function are ported to clients that communicate to the SC.
+ *
+ * @addtogroup PM_SVC
+ * @{
+ */
+
+/* Includes */
+
+#include <soc/imx8/sc/types.h>
+#include <soc/imx8/sc/svc/rm/api.h>
+#include <soc/imx8/sc/svc/pm/api.h>
+#include "../../main/rpc.h"
+#include "rpc.h"
+
+/* Local Defines */
+
+/* Local Types */
+
+/* Local Functions */
+
+sc_err_t sc_pm_set_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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_SET_SYS_POWER_MODE;
+ RPC_D8(&msg, 0) = pt;
+ RPC_D8(&msg, 1) = mode;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_GET_SYS_POWER_MODE;
+ RPC_D8(&msg, 0) = pt;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (mode != NULL)
+ *mode = RPC_D8(&msg, 0);
+ 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_SET_RESOURCE_POWER_MODE;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = mode;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_GET_RESOURCE_POWER_MODE;
+ RPC_D16(&msg, 0) = resource;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (mode != NULL)
+ *mode = RPC_D8(&msg, 0);
+ 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_SET_CLOCK_RATE;
+ RPC_D32(&msg, 0) = *rate;
+ RPC_D16(&msg, 4) = resource;
+ RPC_D8(&msg, 6) = clk;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ *rate = RPC_D32(&msg, 0);
+ 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_GET_CLOCK_RATE;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = clk;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (rate != NULL)
+ *rate = RPC_D32(&msg, 0);
+ 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, bool enable, bool autog)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_CLOCK_ENABLE;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = clk;
+ RPC_D8(&msg, 3) = enable;
+ RPC_D8(&msg, 4) = autog;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_BOOT;
+ RPC_D32(&msg, 0) = boot_addr >> 32;
+ RPC_D32(&msg, 4) = boot_addr;
+ RPC_D16(&msg, 8) = resource_cpu;
+ RPC_D16(&msg, 10) = resource_mu;
+ RPC_D16(&msg, 12) = resource_dev;
+ RPC_D8(&msg, 14) = pt;
+ RPC_SIZE(&msg) = 5;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_REBOOT;
+ RPC_D8(&msg, 0) = type;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, true);
+}
+
+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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_RESET_REASON;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (reason != NULL)
+ *reason = RPC_D8(&msg, 0);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_pm_cpu_start(sc_ipc_t ipc, sc_rsrc_t resource, bool enable,
+ sc_faddr_t address)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_CPU_START;
+ RPC_D32(&msg, 0) = address >> 32;
+ RPC_D32(&msg, 4) = address;
+ RPC_D16(&msg, 8) = resource;
+ RPC_D8(&msg, 10) = enable;
+ RPC_SIZE(&msg) = 4;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_REBOOT_PARTITION;
+ RPC_D8(&msg, 0) = pt;
+ RPC_D8(&msg, 1) = type;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ 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) = SC_RPC_SVC_PM;
+ RPC_FUNC(&msg) = PM_FUNC_RESET;
+ RPC_D8(&msg, 0) = type;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * Header file for the RM RPC implementation.
+ *
+ * @addtogroup RM_SVC
+ * @{
+ */
+
+#ifndef _SC_RM_RPC_H
+#define _SC_RM_RPC_H
+
+/* Includes */
+
+/* Defines */
+
+/* Types */
+
+/*!
+ * This type is used to indicate RPC RM function calls.
+ */
+typedef enum rm_func_e {
+ RM_FUNC_UNKNOWN, /* Unknown function */
+ RM_FUNC_PARTITION_ALLOC, /* Index for rm_partition_alloc() RPC call */
+ RM_FUNC_PARTITION_FREE, /* Index for rm_partition_free() RPC call */
+ RM_FUNC_PARTITION_STATIC, /* Index for rm_partition_static() RPC call */
+ RM_FUNC_PARTITION_LOCK, /* Index for rm_partition_lock() RPC call */
+ RM_FUNC_GET_PARTITION, /* Index for rm_get_partition() RPC call */
+ RM_FUNC_SET_PARENT, /* Index for rm_set_parent() RPC call */
+ RM_FUNC_MOVE_ALL, /* Index for rm_move_all() RPC call */
+ RM_FUNC_ASSIGN_RESOURCE, /* Index for rm_assign_resource() RPC call */
+ RM_FUNC_SET_RESOURCE_MOVABLE, /* Index for rm_set_resource_movable() RPC call */
+ RM_FUNC_SET_MASTER_ATTRIBUTES, /* Index for rm_set_master_attributes() RPC call */
+ RM_FUNC_SET_MASTER_SID, /* Index for rm_set_master_sid() RPC call */
+ RM_FUNC_SET_PERIPHERAL_PERMISSIONS, /* Index for rm_set_peripheral_permissions() RPC call */
+ RM_FUNC_IS_RESOURCE_OWNED, /* Index for rm_is_resource_owned() RPC call */
+ RM_FUNC_IS_RESOURCE_MASTER, /* Index for rm_is_resource_master() RPC call */
+ RM_FUNC_IS_RESOURCE_PERIPHERAL, /* Index for rm_is_resource_peripheral() RPC call */
+ RM_FUNC_GET_RESOURCE_INFO, /* Index for rm_get_resource_info() RPC call */
+ RM_FUNC_MEMREG_ALLOC, /* Index for rm_memreg_alloc() RPC call */
+ RM_FUNC_MEMREG_FREE, /* Index for rm_memreg_free() RPC call */
+ RM_FUNC_ASSIGN_MEMREG, /* Index for rm_assign_memreg() RPC call */
+ RM_FUNC_SET_MEMREG_PERMISSIONS, /* Index for rm_set_memreg_permissions() RPC call */
+ RM_FUNC_IS_MEMREG_OWNED, /* Index for rm_is_memreg_owned() RPC call */
+ RM_FUNC_GET_MEMREG_INFO, /* Index for rm_get_memreg_info() RPC call */
+ RM_FUNC_ASSIGN_PIN, /* Index for rm_assign_pin() RPC call */
+ RM_FUNC_SET_PIN_MOVABLE, /* Index for rm_set_pin_movable() RPC call */
+ RM_FUNC_IS_PIN_OWNED, /* Index for rm_is_pin_owned() RPC call */
+ RM_FUNC_GET_DID, /* Index for rm_get_did() RPC call */
+} rm_func_t;
+
+/* 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 /* _SC_RM_RPC_H */
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * File containing client-side RPC functions for the RM service. These
+ * function are ported to clients that communicate to the SC.
+ *
+ * @addtogroup RM_SVC
+ * @{
+ */
+
+/* Includes */
+
+#include <soc/imx8/sc/types.h>
+#include <soc/imx8/sc/svc/rm/api.h>
+#include "../../main/rpc.h"
+#include "rpc.h"
+
+/* Local Defines */
+
+/* Local Types */
+
+/* Local Functions */
+
+sc_err_t sc_rm_partition_alloc(sc_ipc_t ipc, sc_rm_pt_t *pt, bool secure,
+ bool isolated, bool restricted,
+ bool confidential, bool coherent)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_PARTITION_ALLOC;
+ RPC_D8(&msg, 0) = secure;
+ RPC_D8(&msg, 1) = isolated;
+ RPC_D8(&msg, 2) = restricted;
+ RPC_D8(&msg, 3) = confidential;
+ RPC_D8(&msg, 4) = coherent;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (pt != NULL)
+ *pt = RPC_D8(&msg, 0);
+ 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_PARTITION_FREE;
+ RPC_D8(&msg, 0) = pt;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_GET_DID;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_PARTITION_STATIC;
+ RPC_D8(&msg, 0) = pt;
+ RPC_D8(&msg, 1) = did;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_PARTITION_LOCK;
+ RPC_D8(&msg, 0) = pt;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_GET_PARTITION;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (pt != NULL)
+ *pt = RPC_D8(&msg, 0);
+ 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_SET_PARENT;
+ RPC_D8(&msg, 0) = pt;
+ RPC_D8(&msg, 1) = pt_parent;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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,
+ bool move_rsrc, bool move_pins)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_MOVE_ALL;
+ RPC_D8(&msg, 0) = pt_src;
+ RPC_D8(&msg, 1) = pt_dst;
+ RPC_D8(&msg, 2) = move_rsrc;
+ RPC_D8(&msg, 3) = move_pins;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_ASSIGN_RESOURCE;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = pt;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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, bool movable)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_SET_RESOURCE_MOVABLE;
+ RPC_D16(&msg, 0) = resource_fst;
+ RPC_D16(&msg, 2) = resource_lst;
+ RPC_D8(&msg, 4) = movable;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, 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,
+ bool smmu_bypass)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_SET_MASTER_ATTRIBUTES;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = sa;
+ RPC_D8(&msg, 3) = pa;
+ RPC_D8(&msg, 4) = smmu_bypass;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_SET_MASTER_SID;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D16(&msg, 2) = sid;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_SET_PERIPHERAL_PERMISSIONS;
+ RPC_D16(&msg, 0) = resource;
+ RPC_D8(&msg, 2) = pt;
+ RPC_D8(&msg, 3) = perm;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+bool 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_OWNED;
+ RPC_D16(&msg, 0) = resource;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (bool) result;
+}
+
+bool 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_MASTER;
+ RPC_D16(&msg, 0) = resource;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (bool) result;
+}
+
+bool 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_PERIPHERAL;
+ RPC_D16(&msg, 0) = resource;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (bool) 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_GET_RESOURCE_INFO;
+ RPC_D16(&msg, 0) = resource;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (sid != NULL)
+ *sid = RPC_D16(&msg, 0);
+ 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_MEMREG_ALLOC;
+ RPC_D32(&msg, 0) = addr_start >> 32;
+ RPC_D32(&msg, 4) = addr_start;
+ RPC_D32(&msg, 8) = addr_end >> 32;
+ RPC_D32(&msg, 12) = addr_end;
+ RPC_SIZE(&msg) = 5;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ if (mr != NULL)
+ *mr = RPC_D8(&msg, 0);
+ 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_MEMREG_FREE;
+ RPC_D8(&msg, 0) = mr;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_ASSIGN_MEMREG;
+ RPC_D8(&msg, 0) = pt;
+ RPC_D8(&msg, 1) = mr;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_SET_MEMREG_PERMISSIONS;
+ RPC_D8(&msg, 0) = mr;
+ RPC_D8(&msg, 1) = pt;
+ RPC_D8(&msg, 2) = perm;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+bool 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_IS_MEMREG_OWNED;
+ RPC_D8(&msg, 0) = mr;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (bool) 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) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_GET_MEMREG_INFO;
+ RPC_D8(&msg, 0) = mr;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (addr_start != NULL)
+ *addr_start =
+ ((uint64_t) RPC_D32(&msg, 0) << 32) | RPC_D32(&msg, 4);
+ if (addr_end != NULL)
+ *addr_end =
+ ((uint64_t) RPC_D32(&msg, 8) << 32) | RPC_D32(&msg, 12);
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_rm_assign_pin(sc_ipc_t ipc, sc_rm_pt_t pt, sc_pin_t pin)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_ASSIGN_PIN;
+ RPC_D16(&msg, 0) = pin;
+ RPC_D8(&msg, 2) = pt;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_rm_set_pin_movable(sc_ipc_t ipc, sc_pin_t pin_fst,
+ sc_pin_t pin_lst, bool movable)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_SET_PIN_MOVABLE;
+ RPC_D16(&msg, 0) = pin_fst;
+ RPC_D16(&msg, 2) = pin_lst;
+ RPC_D8(&msg, 4) = movable;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+bool sc_rm_is_pin_owned(sc_ipc_t ipc, sc_pin_t pin)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_RM;
+ RPC_FUNC(&msg) = RM_FUNC_IS_PIN_OWNED;
+ RPC_D8(&msg, 0) = pin;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (bool) result;
+}
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * Header file for the TIMER RPC implementation.
+ *
+ * @addtogroup TIMER_SVC
+ * @{
+ */
+
+#ifndef _SC_TIMER_RPC_H
+#define _SC_TIMER_RPC_H
+
+/* Includes */
+
+/* Defines */
+
+/* Types */
+
+/*!
+ * This type is used to indicate RPC TIMER function calls.
+ */
+typedef enum timer_func_e {
+ TIMER_FUNC_UNKNOWN, /* Unknown function */
+ TIMER_FUNC_SET_WDOG_TIMEOUT, /* Index for timer_set_wdog_timeout() RPC call */
+ TIMER_FUNC_START_WDOG, /* Index for timer_start_wdog() RPC call */
+ TIMER_FUNC_STOP_WDOG, /* Index for timer_stop_wdog() RPC call */
+ TIMER_FUNC_PING_WDOG, /* Index for timer_ping_wdog() RPC call */
+ TIMER_FUNC_GET_WDOG_STATUS, /* Index for timer_get_wdog_status() RPC call */
+ TIMER_FUNC_SET_RTC_TIME, /* Index for timer_set_rtc_time() RPC call */
+ TIMER_FUNC_GET_RTC_TIME, /* Index for timer_get_rtc_time() RPC call */
+ TIMER_FUNC_SET_RTC_ALARM, /* Index for timer_set_rtc_alarm() RPC call */
+ TIMER_FUNC_GET_RTC_SEC1970, /* Index for timer_get_rtc_sec1970() RPC call */
+} timer_func_t;
+
+/* 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 */
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+/*!
+ * File containing client-side RPC functions for the TIMER service. These
+ * function are ported to clients that communicate to the SC.
+ *
+ * @addtogroup TIMER_SVC
+ * @{
+ */
+
+/* Includes */
+
+#include <soc/imx8/sc/types.h>
+#include <soc/imx8/sc/svc/rm/api.h>
+#include <soc/imx8/sc/svc/timer/api.h>
+#include "../../main/rpc.h"
+#include "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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_SET_WDOG_TIMEOUT;
+ RPC_D32(&msg, 0) = timeout;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+sc_err_t sc_timer_start_wdog(sc_ipc_t ipc, bool lock)
+{
+ sc_rpc_msg_t msg;
+ uint8_t result;
+
+ RPC_VER(&msg) = SC_RPC_VERSION;
+ RPC_SVC(&msg) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_START_WDOG;
+ RPC_D8(&msg, 0) = lock;
+ RPC_SIZE(&msg) = 2;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_STOP_WDOG;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_PING_WDOG;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_GET_WDOG_STATUS;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (timeout != NULL)
+ *timeout = RPC_D32(&msg, 0);
+ if (max_timeout != NULL)
+ *max_timeout = RPC_D32(&msg, 4);
+ if (remaining_time != NULL)
+ *remaining_time = RPC_D32(&msg, 8);
+ 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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_SET_RTC_TIME;
+ RPC_D16(&msg, 0) = year;
+ RPC_D8(&msg, 2) = mon;
+ RPC_D8(&msg, 3) = day;
+ RPC_D8(&msg, 4) = hour;
+ RPC_D8(&msg, 5) = min;
+ RPC_D8(&msg, 6) = sec;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_GET_RTC_TIME;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (year != NULL)
+ *year = RPC_D16(&msg, 0);
+ result = RPC_R8(&msg);
+ if (mon != NULL)
+ *mon = RPC_D8(&msg, 2);
+ if (day != NULL)
+ *day = RPC_D8(&msg, 3);
+ if (hour != NULL)
+ *hour = RPC_D8(&msg, 4);
+ if (min != NULL)
+ *min = RPC_D8(&msg, 5);
+ if (sec != NULL)
+ *sec = RPC_D8(&msg, 6);
+ 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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_SET_RTC_ALARM;
+ RPC_D16(&msg, 0) = year;
+ RPC_D8(&msg, 2) = mon;
+ RPC_D8(&msg, 3) = day;
+ RPC_D8(&msg, 4) = hour;
+ RPC_D8(&msg, 5) = min;
+ RPC_D8(&msg, 6) = sec;
+ RPC_SIZE(&msg) = 3;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ result = RPC_R8(&msg);
+ 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) = SC_RPC_SVC_TIMER;
+ RPC_FUNC(&msg) = TIMER_FUNC_GET_RTC_SEC1970;
+ RPC_SIZE(&msg) = 1;
+
+ sc_call_rpc(ipc, &msg, false);
+
+ if (sec != NULL)
+ *sec = RPC_D32(&msg, 0);
+ result = RPC_R8(&msg);
+ return (sc_err_t) result;
+}
+
+/**@}*/
--- /dev/null
+/*
+ * Copyright (C) 2016 Freescale Semiconductor, Inc.
+ * Copyright 2017 NXP
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/sys_soc.h>
+#include <linux/platform_device.h>
+#include <linux/of.h>
+
+struct imx8_soc_data {
+ char *name;
+ u32 (*soc_revision)(void);
+};
+
+u32 imx8qm_soc_revision(void);
+u32 imx8qxp_soc_revision(void);
+
+struct imx8_soc_data imx8qm_soc_data = {
+ .name = "i.MX8QM",
+ .soc_revision = imx8qm_soc_revision,
+};
+
+struct imx8_soc_data imx8qxp_soc_data = {
+ .name = "i.MX8QXP",
+ .soc_revision = imx8qxp_soc_revision,
+};
+
+static const struct of_device_id imx8_soc_match[] = {
+ { .compatible = "fsl,imx8qm", .data = &imx8qm_soc_data, },
+ { .compatible = "fsl,imx8qxp", .data = &imx8qxp_soc_data, },
+ { }
+};
+
+u32 imx8qm_soc_revision(void)
+{
+ /*FIX ME later */
+
+ return 0x10;
+}
+
+u32 imx8qxp_soc_revision(void)
+{
+ /*FIX ME later */
+
+ return 0x10;
+}
+
+static int __init imx8_soc_init(void)
+{
+ struct soc_device_attribute *soc_dev_attr;
+ struct soc_device *soc_dev;
+ struct device_node *root;
+ const struct of_device_id *id;
+ u32 imx_soc_revision = 0;
+ const struct imx8_soc_data *data;
+ int ret;
+
+ soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
+ if (!soc_dev_attr)
+ return -ENODEV;
+
+ soc_dev_attr->family = "Freescale i.MX";
+
+ root = of_find_node_by_path("/");
+ ret = of_property_read_string(root, "model", &soc_dev_attr->machine);
+ if (ret)
+ goto free_soc;
+
+ id = of_match_node(imx8_soc_match, root);
+ if (!id)
+ goto free_soc;
+
+ of_node_put(root);
+
+ data = id->data;
+ if (data) {
+ soc_dev_attr->soc_id = data->name;
+ if (data->soc_revision)
+ imx_soc_revision = data->soc_revision();
+ }
+
+ soc_dev_attr->revision = kasprintf(GFP_KERNEL, "%d.%d",
+ (imx_soc_revision >> 4) & 0xf,
+ imx_soc_revision & 0xf);
+ if (!soc_dev_attr->revision)
+ goto free_soc;
+
+ soc_dev = soc_device_register(soc_dev_attr);
+ if (IS_ERR(soc_dev))
+ goto free_rev;
+
+ return 0;
+
+free_rev:
+ kfree(soc_dev_attr->revision);
+free_soc:
+ kfree(soc_dev_attr);
+ return -ENODEV;
+}
+device_initcall(imx8_soc_init);
+++ /dev/null
-obj-$(CONFIG_ARCH_FSL_IMX8QM) += mu/
-obj-$(CONFIG_ARCH_FSL_IMX8QM) += sc/
-obj-$(CONFIG_ARCH_FSL_IMX8QM) += rpmsg/
-obj-$(CONFIG_ARCH_FSL_IMX8QM) += pm-domains.o soc-imx8.o
+++ /dev/null
-obj-y += mx8_mu.o
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-#include <linux/err.h>
-#include <linux/io.h>
-#include "mx8_mu.h"
-
-
-/*!
- * This function enables specific RX full interrupt.
- */
-void MU_EnableRxFullInt(void __iomem *base, uint32_t index)
-{
- uint32_t reg = readl_relaxed(base + MU_ACR_OFFSET1);
-
- reg &= ~(MU_CR_GIRn_MASK1 | MU_CR_NMI_MASK1);
- reg |= ~MU_CR_RIE0_MASK1 >> index;
- writel_relaxed(reg, base + MU_ACR_OFFSET1);
-}
-
-/*!
- * This function enables specific general purpose interrupt.
- */
-void MU_EnableGeneralInt(void __iomem *base, uint32_t index)
-{
- uint32_t reg = readl_relaxed(base + MU_ACR_OFFSET1);
-
- reg &= ~(MU_CR_GIRn_MASK1 | MU_CR_NMI_MASK1);
- reg |= MU_CR_GIE0_MASK1 >> index;
- writel_relaxed(reg, base + MU_ACR_OFFSET1);
-}
-
-/*
- * Wait and send message to the other core.
- */
-void MU_SendMessage(void __iomem *base, uint32_t regIndex, uint32_t msg)
-{
- uint32_t mask = MU_SR_TE0_MASK1 >> regIndex;
-
- /* Wait TX register to be empty. */
- while (!(readl_relaxed(base + MU_ASR_OFFSET1) & mask))
- ;
- writel_relaxed(msg, base + MU_ATR0_OFFSET1 + (regIndex * 4));
-}
-
-
-/*
- * Wait to receive message from the other core.
- */
-void MU_ReceiveMsg(void __iomem *base, uint32_t regIndex, uint32_t *msg)
-{
- uint32_t mask = MU_SR_RF0_MASK1 >> regIndex;
-
- /* Wait RX register to be full. */
- while (!(readl_relaxed(base + MU_ASR_OFFSET1) & mask))
- ;
- *msg = readl_relaxed(base + MU_ARR0_OFFSET1 + (regIndex * 4));
-}
-
-
-
-void MU_Init(void __iomem *base)
-{
- uint32_t reg;
-
- reg = readl_relaxed(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_NMI_MASK1 | MU_CR_Fn_MASK1);
- writel_relaxed(reg, base + MU_ACR_OFFSET1);
-}
-
-/**@}*/
-
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-#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 (0xF << 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 (1 << 31)
-
-#define MU_TR_COUNT 4
-#define MU_RR_COUNT 4
-
-
-void MU_Init(void __iomem *base);
-void MU_SendMessage(void __iomem *base, uint32_t regIndex, uint32_t msg);
-void MU_ReceiveMsg(void __iomem *base, uint32_t regIndex, uint32_t *msg);
-void MU_EnableGeneralInt(void __iomem *base, uint32_t index);
-void MU_EnableRxFullInt(void __iomem *base, uint32_t index);
-
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-
-#ifndef PM_DOMAIN_IMX8_H
-#define PM_DOMAIN_IMX8_H
-
-#include <linux/pm_domain.h>
-#include <soc/imx8/sc/sci.h>
-
-#define DEFAULT_DEV_LATENCY_NS 250000
-
-struct platform_device;
-
-struct imx8_pm_domain {
- const char *name;
- struct generic_pm_domain pd;
- struct dev_power_governor *gov;
- int (*suspend)(void);
- void (*resume)(void);
- sc_rsrc_t rsrc_id;
-};
-
-static inline
-struct imx8_pm_domain *to_imx8_pd(struct generic_pm_domain *d)
-{
- return container_of(d, struct imx8_pm_domain, pd);
-}
-
-struct pm_domain_device {
- const char *domain_name;
- struct platform_device *pdev;
-};
-
-#endif /* PM_DOMAIN_IMX8_H */
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-
-#include <linux/console.h>
-#include <linux/delay.h>
-#include <linux/io.h>
-#include <linux/of.h>
-#include <linux/of_address.h>
-#include <linux/of_platform.h>
-#include <linux/platform_device.h>
-#include <linux/pm.h>
-#include <linux/pm_clock.h>
-#include <linux/slab.h>
-
-#include <soc/imx8/sc/sci.h>
-
-#include "pm-domain-imx8.h"
-
-static sc_ipc_t pm_ipc_handle;
-
-static int imx8_pd_power(struct generic_pm_domain *domain, bool power_on)
-{
- struct imx8_pm_domain *pd;
- sc_err_t sci_err;
-
- pd = container_of(domain, struct imx8_pm_domain, pd);
-
- if (pd->rsrc_id == SC_R_LAST)
- return 0;
-
- sci_err = sc_pm_set_resource_power_mode(pm_ipc_handle, pd->rsrc_id,
- (power_on) ? SC_PM_PW_MODE_ON : SC_PM_PW_MODE_OFF);
-
- if (sci_err)
- pr_err("Failed power operation on resource %d\n", pd->rsrc_id);
-
- return 0;
-}
-
-static int imx8_pd_power_on(struct generic_pm_domain *domain)
-{
- return imx8_pd_power(domain, true);
-}
-
-static int imx8_pd_power_off(struct generic_pm_domain *domain)
-{
- return imx8_pd_power(domain, false);
-}
-
-static int __init imx8_add_pm_domains(struct device_node *parent,
- struct generic_pm_domain *genpd_parent)
-{
- struct device_node *np;
-
- for_each_child_of_node(parent, np) {
- struct imx8_pm_domain *imx8_pd;
- sc_rsrc_t rsrc_id;
-
- imx8_pd = kzalloc(sizeof(*imx8_pd), GFP_KERNEL);
- if (!imx8_pd)
- return -ENOMEM;
-
- if (!of_property_read_string(np, "name", &imx8_pd->pd.name))
- imx8_pd->name = imx8_pd->pd.name;
-
- if (!of_property_read_u32(np, "reg", &rsrc_id))
- imx8_pd->rsrc_id = rsrc_id;
-
- imx8_pd->pd.power_off = imx8_pd_power_off;
- imx8_pd->pd.power_on = imx8_pd_power_on;
-
- pm_genpd_init(&imx8_pd->pd, NULL, true);
-
- if (genpd_parent)
- pm_genpd_add_subdomain(genpd_parent, &imx8_pd->pd);
-
- of_genpd_add_provider_simple(np, &imx8_pd->pd);
-
- imx8_add_pm_domains(np, &imx8_pd->pd);
- }
- return 0;
-}
-
-static int __init imx8_init_pm_domains(void)
-{
- struct device_node *np;
- sc_err_t sci_err;
- sc_rsrc_t rsrc_id;
- uint32_t mu_id;
-
- /* skip pm domains for non-SCFW system */
- if (!of_find_compatible_node(NULL, NULL, "nxp,imx8-pd"))
- return 0;
-
- pr_info("***** imx8_init_pm_domains *****\n");
-
- for_each_compatible_node(np, NULL, "nxp,imx8-pd") {
- struct imx8_pm_domain *imx8_pd;
-
- imx8_pd = kzalloc(sizeof(struct imx8_pm_domain), GFP_KERNEL);
- if (!imx8_pd) {
- pr_err("%s: failed to allocate memory for domain\n",
- __func__);
- return -ENOMEM;
- }
- if (!of_property_read_string(np, "name", &imx8_pd->pd.name))
- imx8_pd->name = imx8_pd->pd.name;
-
- if (!of_property_read_u32(np, "reg", &rsrc_id))
- imx8_pd->rsrc_id = rsrc_id;
-
- if (imx8_pd->rsrc_id != SC_R_LAST) {
- imx8_pd->pd.power_off = imx8_pd_power_off;
- imx8_pd->pd.power_on = imx8_pd_power_on;
- }
- pm_genpd_init(&imx8_pd->pd, NULL, true);
- of_genpd_add_provider_simple(np, &imx8_pd->pd);
- imx8_add_pm_domains(np, &imx8_pd->pd);
- }
-
- sci_err = sc_ipc_getMuID(&mu_id);
- if (sci_err != SC_ERR_NONE) {
- pr_info("Cannot obtain MU ID\n");
- return sci_err;
- }
-
- sci_err = sc_ipc_open(&pm_ipc_handle, mu_id);
-
- return 0;
-}
-
-early_initcall(imx8_init_pm_domains);
+++ /dev/null
-obj-y += imx_rpmsg.o
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- */
-
-#include <linux/dma-mapping.h>
-#include <linux/err.h>
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/module.h>
-#include <linux/notifier.h>
-#include <linux/of.h>
-#include <linux/of_address.h>
-#include <linux/of_irq.h>
-#include <linux/of_reserved_mem.h>
-#include <linux/platform_device.h>
-#include <linux/rpmsg.h>
-#include <linux/slab.h>
-#include <linux/virtio.h>
-#include <linux/virtio_config.h>
-#include <linux/virtio_ids.h>
-#include <linux/virtio_ring.h>
-#include "../mu/mx8_mu.h"
-
-#define MU_ARR1_OFFSET 0x14
-#define MU_ASR 0x20
-
-static void __iomem *mu_base;
-static u32 m4_message;
-static struct delayed_work rpmsg_work;
-
-struct imx_mu_rpmsg_box {
- const char *name;
- struct blocking_notifier_head notifier;
-};
-
-static struct imx_mu_rpmsg_box mu_rpmsg_box = {
- .name = "m4",
-};
-
-struct imx_rpmsg_vproc {
- struct virtio_device vdev;
- dma_addr_t vring[2];
- char *rproc_name;
- struct mutex lock;
- struct notifier_block nb;
- struct virtqueue *vq[2];
- int base_vq_id;
- int num_of_vqs;
-};
-
-/*
- * For now, allocate 256 buffers of 512 bytes for each side. each buffer
- * will then have 16B for the msg header and 496B for the payload.
- * This will require a total space of 256KB for the buffers themselves, and
- * 3 pages for every vring (the size of the vring depends on the number of
- * buffers it supports).
- */
-#define RPMSG_NUM_BUFS (512)
-#define RPMSG_BUF_SIZE (512)
-#define RPMSG_BUFS_SPACE (RPMSG_NUM_BUFS * RPMSG_BUF_SIZE)
-
-/*
- * The alignment between the consumer and producer parts of the vring.
- * Note: this is part of the "wire" protocol. If you change this, you need
- * to update your BIOS image as well
- */
-#define RPMSG_VRING_ALIGN (4096)
-
-/* With 256 buffers, our vring will occupy 3 pages */
-#define RPMSG_RING_SIZE ((DIV_ROUND_UP(vring_size(RPMSG_NUM_BUFS / 2, \
- RPMSG_VRING_ALIGN), PAGE_SIZE)) * PAGE_SIZE)
-
-#define to_imx_rpdev(vd) container_of(vd, struct imx_rpmsg_vproc, vdev)
-
-struct imx_rpmsg_vq_info {
- __u16 num; /* number of entries in the virtio_ring */
- __u16 vq_id; /* a globaly unique index of this virtqueue */
- void *addr; /* address where we mapped the virtio ring */
- struct imx_rpmsg_vproc *rpdev;
-};
-
-static u64 imx_rpmsg_get_features(struct virtio_device *vdev)
-{
- return 1 << VIRTIO_RPMSG_F_NS;
-}
-
-static int imx_rpmsg_finalize_features(struct virtio_device *vdev)
-{
- /* Give virtio_ring a chance to accept features */
- vring_transport_features(vdev);
- return 0;
-}
-
-/* kick the remote processor, and let it know which virtqueue to poke at */
-static bool imx_rpmsg_notify(struct virtqueue *vq)
-{
- unsigned int mu_rpmsg = 0;
- struct imx_rpmsg_vq_info *rpvq = vq->priv;
-
- mu_rpmsg = rpvq->vq_id << 16;
- mutex_lock(&rpvq->rpdev->lock);
- /* send the index of the triggered virtqueue as the mu payload */
- MU_SendMessage(mu_base, 1, mu_rpmsg);
- mutex_unlock(&rpvq->rpdev->lock);
-
- return true;
-}
-
-static int imx_mu_rpmsg_callback(struct notifier_block *this,
- unsigned long index, void *data)
-{
- u32 mu_msg = (u64) data;
- struct imx_rpmsg_vproc *rpdev;
-
- rpdev = container_of(this, struct imx_rpmsg_vproc, nb);
-
- pr_debug("%s mu_msg: 0x%x\n", __func__, mu_msg);
-
- /* ignore vq indices which are clearly not for us */
- mu_msg = mu_msg >> 16;
- if (mu_msg < rpdev->base_vq_id)
- pr_err("mu_msg: 0x%x is invalid\n", mu_msg);
-
- mu_msg -= rpdev->base_vq_id;
-
- /*
- * Currently both PENDING_MSG and explicit-virtqueue-index
- * messaging are supported.
- * Whatever approach is taken, at this point 'mu_msg' contains
- * the index of the vring which was just triggered.
- */
- if (mu_msg < rpdev->num_of_vqs)
- vring_interrupt(mu_msg, rpdev->vq[mu_msg]);
-
- return NOTIFY_DONE;
-}
-
-int imx_mu_rpmsg_register_nb(const char *name, struct notifier_block *nb)
-{
- if ((name == NULL) || (nb == NULL))
- return -EINVAL;
-
- if (!strcmp(mu_rpmsg_box.name, name))
- blocking_notifier_chain_register(&(mu_rpmsg_box.notifier), nb);
- else
- return -ENOENT;
-
- return 0;
-}
-
-int imx_mu_rpmsg_unregister_nb(const char *name, struct notifier_block *nb)
-{
- if ((name == NULL) || (nb == NULL))
- return -EINVAL;
-
- if (!strcmp(mu_rpmsg_box.name, name))
- blocking_notifier_chain_unregister(&(mu_rpmsg_box.notifier),
- nb);
- else
- return -ENOENT;
-
- return 0;
-}
-
-static struct virtqueue *rp_find_vq(struct virtio_device *vdev,
- unsigned index,
- void (*callback)(struct virtqueue *vq),
- const char *name)
-{
- struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
- struct imx_rpmsg_vq_info *rpvq;
- struct virtqueue *vq;
- int err;
-
- rpvq = kmalloc(sizeof(*rpvq), GFP_KERNEL);
- if (!rpvq)
- return ERR_PTR(-ENOMEM);
-
- dma_alloc_from_coherent(vdev->dev.parent, 0x8000,
- &rpdev->vring[index], &rpvq->addr);
- if (!rpvq->addr) {
- err = -ENOMEM;
- goto free_rpvq;
- }
-
- pr_debug("vring%d: phys 0x%llx, virt 0x%p\n", index, rpdev->vring[index],
- rpvq->addr);
- vq = vring_new_virtqueue(index, RPMSG_NUM_BUFS / 2, RPMSG_VRING_ALIGN,
- vdev, true, rpvq->addr, imx_rpmsg_notify, callback,
- name);
- if (!vq) {
- pr_err("vring_new_virtqueue failed\n");
- err = -ENOMEM;
- goto unmap_vring;
- }
-
- rpdev->vq[index] = vq;
- vq->priv = rpvq;
- /* system-wide unique id for this virtqueue */
- rpvq->vq_id = rpdev->base_vq_id + index;
- rpvq->rpdev = rpdev;
- mutex_init(&rpdev->lock);
-
- return vq;
-
-unmap_vring:
- /* iounmap normal memory, so make sparse happy */
- iounmap((__force void __iomem *) rpvq->addr);
-free_rpvq:
- kfree(rpvq);
- return ERR_PTR(err);
-}
-
-static void imx_rpmsg_del_vqs(struct virtio_device *vdev)
-{
- struct virtqueue *vq, *n;
- struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
-
- list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
- struct imx_rpmsg_vq_info *rpvq = vq->priv;
-
- iounmap(rpvq->addr);
- vring_del_virtqueue(vq);
- kfree(rpvq);
- }
-
- if (&rpdev->nb)
- imx_mu_rpmsg_unregister_nb((const char *)rpdev->rproc_name,
- &rpdev->nb);
-}
-
-static int imx_rpmsg_find_vqs(struct virtio_device *vdev, unsigned nvqs,
- struct virtqueue *vqs[],
- vq_callback_t *callbacks[],
- const char * const names[])
-{
- struct imx_rpmsg_vproc *rpdev = to_imx_rpdev(vdev);
- int i, err;
-
- /* we maintain two virtqueues per remote processor (for RX and TX) */
- if (nvqs != 2)
- return -EINVAL;
-
- for (i = 0; i < nvqs; ++i) {
- vqs[i] = rp_find_vq(vdev, i, callbacks[i], names[i]);
- if (IS_ERR(vqs[i])) {
- err = PTR_ERR(vqs[i]);
- goto error;
- }
- }
-
- rpdev->num_of_vqs = nvqs;
-
- rpdev->nb.notifier_call = imx_mu_rpmsg_callback;
- imx_mu_rpmsg_register_nb((const char *)rpdev->rproc_name, &rpdev->nb);
-
- return 0;
-
-error:
- imx_rpmsg_del_vqs(vdev);
- return err;
-}
-
-static void imx_rpmsg_reset(struct virtio_device *vdev)
-{
- dev_dbg(&vdev->dev, "reset !\n");
-}
-
-static u8 imx_rpmsg_get_status(struct virtio_device *vdev)
-{
- return 0;
-}
-
-static void imx_rpmsg_set_status(struct virtio_device *vdev, u8 status)
-{
- dev_dbg(&vdev->dev, "%s new status: %d\n", __func__, status);
-}
-
-static void imx_rpmsg_vproc_release(struct device *dev)
-{
- /* this handler is provided so driver core doesn't yell at us */
-}
-
-static struct virtio_config_ops imx_rpmsg_config_ops = {
- .get_features = imx_rpmsg_get_features,
- .finalize_features = imx_rpmsg_finalize_features,
- .find_vqs = imx_rpmsg_find_vqs,
- .del_vqs = imx_rpmsg_del_vqs,
- .reset = imx_rpmsg_reset,
- .set_status = imx_rpmsg_set_status,
- .get_status = imx_rpmsg_get_status,
-};
-
-static struct imx_rpmsg_vproc imx_rpmsg_vprocs[] = {
- {
- .vdev.id.device = VIRTIO_ID_RPMSG,
- .vdev.config = &imx_rpmsg_config_ops,
- .rproc_name = "m4",
- .base_vq_id = 0,
- },
-};
-
-static const struct of_device_id imx_rpmsg_dt_ids[] = {
- { .compatible = "fsl,imx8dv-rpmsg", },
- { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, imx_rpmsg_dt_ids);
-
-static void rpmsg_work_handler(struct work_struct *work)
-{
- u64 val = m4_message;
-
- blocking_notifier_call_chain(&(mu_rpmsg_box.notifier), 4, (void *)val);
- m4_message = 0;
-}
-
-static irqreturn_t imx8_mu_rpmsg_isr(int irq, void *param)
-{
- u32 irqs;
-
- irqs = readl_relaxed(mu_base + MU_ASR);
-
- /* RPMSG */
- if (irqs & (1 << 26)) {
- /* get message from receive buffer */
- MU_ReceiveMsg(mu_base, 1, &m4_message);
- schedule_delayed_work(&rpmsg_work, 0);
- }
-
- return IRQ_HANDLED;
-}
-
-static int imx_rpmsg_probe(struct platform_device *pdev)
-{
- int i, ret = 0;
- u32 irq, val;
- struct device_node *np;
-
- /* Initialize the mu unit used by rpmsg */
- np = of_find_compatible_node(NULL, NULL, "fsl,imx8-mu-rpmsg");
- if (!np)
- pr_info("Cannot find MU-RPMSG entry in device tree\n");
-
- /* Make check the MU is initialized by CM4_0 or not */
- if (of_property_read_u32(np, "mu_is_run", &val) < 0)
- return -ENODEV;
-
- mu_base = of_iomap(np, 0);
- WARN_ON(!mu_base);
-
- irq = of_irq_get(np, 0);
-
- ret = request_irq(irq, imx8_mu_rpmsg_isr, IRQF_EARLY_RESUME,
- "imx8_mu_rpmsg_isr", &mu_rpmsg_box);
- if (ret) {
- pr_info("imx8_mu_init :request_irq failed %d, ret = %d\n",
- irq, ret);
- }
-
- /* Init MU */
- MU_Init(mu_base);
- /* enable the bit26(RIE1) */
- MU_EnableRxFullInt(mu_base, 1);
-
- INIT_DELAYED_WORK(&rpmsg_work, rpmsg_work_handler);
- BLOCKING_INIT_NOTIFIER_HEAD(&(mu_rpmsg_box.notifier));
-
- pr_info("MU is ready for cross core communication!\n");
-
- /* register the virtual processor */
- np = pdev->dev.of_node;
- for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
- struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
-
- if (!strcmp(rpdev->rproc_name, "m4")) {
- ret = of_device_is_compatible(np, "fsl,imx8dv-rpmsg");
- if (ret) {
- of_reserved_mem_device_init(&pdev->dev);
- } else {
- /* hardcodes here now. */
- rpdev->vring[0] = 0xFFFF0000;
- rpdev->vring[1] = 0xFFFF8000;
- }
- } else {
- break;
- }
-
- pr_debug("%s rpdev%d: vring0 0x%llx, vring1 0x%llx\n", __func__,
- i, rpdev->vring[0], rpdev->vring[1]);
-
- rpdev->vdev.dev.parent = &pdev->dev;
- rpdev->vdev.dev.release = imx_rpmsg_vproc_release;
-
- ret = register_virtio_device(&rpdev->vdev);
- if (ret) {
- pr_err("%s failed to register rpdev: %d\n",
- __func__, ret);
- break;
- }
- }
-
- return ret;
-}
-
-static int imx_rpmsg_remove(struct platform_device *pdev)
-{
- int i;
-
- for (i = 0; i < ARRAY_SIZE(imx_rpmsg_vprocs); i++) {
- struct imx_rpmsg_vproc *rpdev = &imx_rpmsg_vprocs[i];
-
- unregister_virtio_device(&rpdev->vdev);
- }
- return 0;
-}
-
-static struct platform_driver imx_rpmsg_driver = {
- .driver = {
- .owner = THIS_MODULE,
- .name = "imx-rpmsg",
- .of_match_table = imx_rpmsg_dt_ids,
- },
- .probe = imx_rpmsg_probe,
- .remove = imx_rpmsg_remove,
-};
-
-static int __init imx_rpmsg_init(void)
-{
- int ret;
-
- ret = platform_driver_register(&imx_rpmsg_driver);
- if (ret)
- pr_err("Unable to initialize rpmsg driver\n");
- else
- pr_info("imx rpmsg driver is registered.\n");
-
- return ret;
-}
-
-static void __exit imx_rpmsg_exit(void)
-{
- pr_info("imx rpmsg driver is unregistered.\n");
- platform_driver_unregister(&imx_rpmsg_driver);
-}
-
-module_exit(imx_rpmsg_exit);
-module_init(imx_rpmsg_init);
-
-MODULE_AUTHOR("Freescale Semiconductor, Inc.");
-MODULE_DESCRIPTION("iMX remote processor messaging virtio device");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-obj-y += main/ipc.o
-obj-y += svc/misc/rpc_clnt.o
-obj-y += svc/pad/rpc_clnt.o
-obj-y += svc/pm/rpc_clnt.o
-obj-y += svc/rm/rpc_clnt.o
-obj-y += svc/timer/rpc_clnt.o
-obj-y += svc/irq/rpc_clnt.o
-
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/* Includes */
-#include <linux/err.h>
-#include <linux/kernel.h>
-#include <linux/of.h>
-#include <linux/of_irq.h>
-#include <linux/of_address.h>
-#include <linux/of_device.h>
-#include <linux/of_fdt.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-
-#include <soc/imx8/sc/svc/irq/api.h>
-#include <soc/imx8/sc/ipc.h>
-#include <soc/imx8/sc/sci.h>
-
-#include "../../mu/mx8_mu.h"
-#include "rpc.h"
-
-/* Local Defines */
-#define MU_SIZE 0x10000
-
-/* Local Types */
-unsigned int scu_mu_id;
-static void __iomem *mu_base_virtaddr;
-static struct delayed_work scu_mu_work;
-static sc_ipc_t mu_ipcHandle;
-
-/* Local functions */
-
-/* Local variables */
-static uint32_t gIPCport;
-static bool scu_mu_init;
-
-DEFINE_MUTEX(scu_mu_mutex);
-
-static BLOCKING_NOTIFIER_HEAD(SCU_notifier_chain);
-
-EXPORT_SYMBOL(sc_pm_set_resource_power_mode);
-EXPORT_SYMBOL(sc_pm_get_resource_power_mode);
-EXPORT_SYMBOL(sc_pm_cpu_start);
-EXPORT_SYMBOL(sc_misc_set_control);
-EXPORT_SYMBOL(sc_pm_clock_enable);
-EXPORT_SYMBOL(sc_pm_set_clock_rate);
-EXPORT_SYMBOL(sc_pad_set_gp_28lpp);
-/*--------------------------------------------------------------------------*/
-/* RPC command/response */
-/*--------------------------------------------------------------------------*/
-void sc_call_rpc(sc_ipc_t handle, sc_rpc_msg_t *msg, bool no_resp)
-{
- if (in_interrupt()) {
- pr_warn("Cannot make SC IPC calls from an interrupt context\n");
- dump_stack();
- return;
- }
- mutex_lock(&scu_mu_mutex);
-
- sc_ipc_write(handle, msg);
- if (!no_resp)
- sc_ipc_read(handle, msg);
-
- mutex_unlock(&scu_mu_mutex);
-}
-EXPORT_SYMBOL(sc_call_rpc);
-
-/*--------------------------------------------------------------------------*/
-/* Get MU base address for specified IPC channel */
-/*--------------------------------------------------------------------------*/
-static uint32_t *sc_ipc_get_mu_base(uint32_t id)
-{
- uint32_t *base;
-
- /* Check parameters */
- if (id >= SC_NUM_IPC)
- base = NULL;
- else
- base = (uint32_t *) (mu_base_virtaddr + (id * MU_SIZE));
-
- return base;
-}
-
-/*--------------------------------------------------------------------------*/
-/* Get the MU ID used by Linux */
-/*--------------------------------------------------------------------------*/
-int sc_ipc_getMuID(uint32_t *mu_id)
-{
- if (scu_mu_init) {
- *mu_id = scu_mu_id;
- return SC_ERR_NONE;
- }
- return SC_ERR_UNAVAILABLE;
-}
-
-EXPORT_SYMBOL(sc_ipc_getMuID);
-
-/*--------------------------------------------------------------------------*/
-/* Open an IPC channel */
-/*--------------------------------------------------------------------------*/
-sc_err_t sc_ipc_requestInt(sc_ipc_t *handle, uint32_t id)
-{
- return SC_ERR_NONE;
-}
-
-/*--------------------------------------------------------------------------*/
-/* Open an IPC channel */
-/*--------------------------------------------------------------------------*/
-sc_err_t sc_ipc_open(sc_ipc_t *handle, uint32_t id)
-{
- uint32_t *base;
-
- mutex_lock(&scu_mu_mutex);
-
- if (!scu_mu_init) {
- mutex_unlock(&scu_mu_mutex);
- return SC_ERR_UNAVAILABLE;
- }
- /* Get MU base associated with IPC channel */
- base = sc_ipc_get_mu_base(id);
-
- if (base == NULL) {
- mutex_unlock(&scu_mu_mutex);
- return SC_ERR_IPC;
- }
-
- *handle = (sc_ipc_t) task_pid_vnr(current);
-
- mutex_unlock(&scu_mu_mutex);
-
- return SC_ERR_NONE;
-}
-EXPORT_SYMBOL(sc_ipc_open);
-/*--------------------------------------------------------------------------*/
-/* Close an IPC channel */
-/*--------------------------------------------------------------------------*/
-void sc_ipc_close(sc_ipc_t handle)
-{
- uint32_t *base;
-
- mutex_lock(&scu_mu_mutex);
-
- if (!scu_mu_init) {
- mutex_unlock(&scu_mu_mutex);
- return;
- }
-
- /* Get MU base associated with IPC channel */
- base = sc_ipc_get_mu_base(gIPCport);
-
- /* TBD ***** What needs to be done here? */
- mutex_unlock(&scu_mu_mutex);
-}
-EXPORT_SYMBOL(sc_ipc_close);
-
-/*!
- * This function reads a message from an IPC channel.
- *
- * @param[in] ipc id of channel read from
- * @param[out] data pointer to message buffer to read
- *
- * This function will block if no message is available to be read.
- */
-void sc_ipc_read(sc_ipc_t handle, void *data)
-{
- uint32_t *base;
- uint8_t count = 0;
- sc_rpc_msg_t *msg = (sc_rpc_msg_t *) data;
-
- /* Get MU base associated with IPC channel */
- base = sc_ipc_get_mu_base(gIPCport);
-
- if ((base == NULL) || (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.d32[count - 1]));
- count++;
- }
-}
-
-/*!
- * This function writes a message to an IPC channel.
- *
- * @param[in] ipc id of channel to write to
- * @param[in] data pointer to message buffer to write
- *
- * This function will block if the outgoing buffer is full.
- */
-void sc_ipc_write(sc_ipc_t handle, void *data)
-{
- uint32_t *base;
- uint8_t count = 0;
- sc_rpc_msg_t *msg = (sc_rpc_msg_t *) data;
-
- /* Get MU base associated with IPC channel */
- base = sc_ipc_get_mu_base(gIPCport);
-
- if ((base == NULL) || (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.d32[count - 1]);
- count++;
- }
-}
-
-int register_scu_notifier(struct notifier_block *nb)
-{
- return blocking_notifier_chain_register(&SCU_notifier_chain, nb);
-}
-
-EXPORT_SYMBOL(register_scu_notifier);
-
-int unregister_scu_notifier(struct notifier_block *nb)
-{
- return blocking_notifier_chain_unregister(&SCU_notifier_chain, nb);
-}
-
-EXPORT_SYMBOL(unregister_scu_notifier);
-
-static int SCU_notifier_call_chain(unsigned long val)
-{
- return (blocking_notifier_call_chain(&SCU_notifier_chain, val, NULL) ==
- NOTIFY_BAD) ? -EINVAL : 0;
-}
-
-static void scu_mu_work_handler(struct work_struct *work)
-{
- uint32_t irq_status;
- sc_err_t sciErr;
-
- /* Figure out what caused the interrupt. */
- sciErr = sc_irq_status(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_TEMP,
- &irq_status);
-
- if (irq_status & (SC_IRQ_TEMP_PMIC0_HIGH | SC_IRQ_TEMP_PMIC1_HIGH))
- SCU_notifier_call_chain(irq_status);
-
- sciErr = sc_irq_status(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_RTC,
- &irq_status);
-
- if (irq_status & SC_IRQ_RTC)
- SCU_notifier_call_chain(irq_status);
-}
-
-static irqreturn_t imx8_scu_mu_isr(int irq, void *param)
-{
- u32 irqs;
-
- irqs = (readl_relaxed(mu_base_virtaddr + 0x20) & (0xf << 28));
- if (irqs) {
- /* Clear the General Interrupt */
- writel_relaxed(irqs, mu_base_virtaddr + 0x20);
- /* Setup a bottom-half to handle the irq work. */
- schedule_delayed_work(&scu_mu_work, 0);
- }
- return IRQ_HANDLED;
-}
-
-/*Initialization of the MU code. */
-int __init imx8_mu_init(void)
-{
- struct device_node *np;
- u32 irq;
- int err;
- sc_err_t sciErr;
-
- /*
- * Get the address of MU to be used for communication with the SCU
- */
- np = of_find_compatible_node(NULL, NULL, "fsl,imx8-mu");
- if (!np) {
- pr_info("Cannot find MU entry in device tree\n");
- return 0;
- }
- mu_base_virtaddr = of_iomap(np, 0);
- WARN_ON(!mu_base_virtaddr);
-
- err = of_property_read_u32_index(np, "fsl,scu_ap_mu_id", 0, &scu_mu_id);
- if (err)
- pr_info("imx8_mu_init: Cannot get mu_id err = %d\n", err);
-
- irq = of_irq_get(np, 0);
-
- err = request_irq(irq, imx8_scu_mu_isr,
- IRQF_EARLY_RESUME, "imx8_mu_isr", NULL);
-
- if (err) {
- pr_info("imx8_mu_init :request_irq failed %d, err = %d\n", irq,
- err);
- }
-
- if (!scu_mu_init) {
- uint32_t i;
-
- INIT_DELAYED_WORK(&scu_mu_work, scu_mu_work_handler);
-
- /* Init MU */
- MU_Init(mu_base_virtaddr);
-
-#if 1
- /* Enable all RX interrupts */
- for (i = 0; i < MU_RR_COUNT; i++)
- MU_EnableGeneralInt(mu_base_virtaddr, i);
-#endif
- gIPCport = scu_mu_id;
- scu_mu_init = true;
- }
-
- sciErr = sc_ipc_open(&mu_ipcHandle, scu_mu_id);
- if (sciErr != SC_ERR_NONE) {
- pr_info("Cannot open MU channel to SCU\n");
- return sciErr;
- };
-
- /* Request for the high temp interrupt. */
- sciErr = sc_irq_enable(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_TEMP,
- SC_IRQ_TEMP_PMIC0_HIGH, true);
-
- if (sciErr)
- pr_info("Cannot request PMIC0_TEMP interrupt\n");
-
- /* Request for the high temp interrupt. */
- sciErr = sc_irq_enable(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_TEMP,
- SC_IRQ_TEMP_PMIC1_HIGH, true);
-
- if (sciErr)
- pr_info("Cannot request PMIC1_TEMP interrupt\n");
-
- /* Request for the rtc alarm interrupt. */
- sciErr = sc_irq_enable(mu_ipcHandle, SC_R_MU_0A, SC_IRQ_GROUP_RTC,
- SC_IRQ_RTC, true);
-
- if (sciErr)
- pr_info("Cannot request ALARM_RTC interrupt\n");
-
- pr_info("*****Initialized MU\n");
- return scu_mu_id;
-}
-
-early_initcall(imx8_mu_init);
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * Header file for the RPC implementation.
- */
-
-#ifndef _SC_RPC_H
-#define _SC_RPC_H
-
-/* Includes */
-
-#include <soc/imx8/sc/types.h>
-#include <soc/imx8/sc/ipc.h>
-
-/* Defines */
-
-#define SC_RPC_VERSION 1
-
-#define SC_RPC_MAX_MSG 8
-
-#define RPC_VER(MSG) ((MSG)->version)
-#define RPC_SIZE(MSG) ((MSG)->size)
-#define RPC_SVC(MSG) ((MSG)->svc)
-#define RPC_FUNC(MSG) ((MSG)->func)
-#define RPC_R8(MSG) ((MSG)->func)
-#define RPC_D32(MSG, IDX) ((MSG)->DATA.d32[IDX / 4])
-#define RPC_F32(MSG, IDX) ((MSG)->DATA.f32[IDX / 4])
-#define RPC_D16(MSG, IDX) ((MSG)->DATA.d16[IDX / 2])
-#define RPC_D8(MSG, IDX) ((MSG)->DATA.d8[IDX])
-
-/* Types */
-
-typedef enum sc_rpc_svc_e {
- SC_RPC_SVC_UNKNOWN = 0,
- SC_RPC_SVC_RETURN = 1,
- SC_RPC_SVC_PM = 2,
- SC_RPC_SVC_RM = 3,
- SC_RPC_SVC_TIMER = 5,
- SC_RPC_SVC_PAD = 6,
- SC_RPC_SVC_MISC = 7,
- SC_RPC_SVC_IRQ = 8,
- SC_RPC_SVC_ABORT = 9
-} sc_rpc_svc_t;
-
-typedef struct sc_rpc_msg_s {
- uint8_t version;
- uint8_t size;
- uint8_t svc;
- uint8_t func;
- union {
- uint32_t d32[(SC_RPC_MAX_MSG - 1)];
- uint16_t d16[(SC_RPC_MAX_MSG - 1) * 2];
- uint8_t d8[(SC_RPC_MAX_MSG - 1) * 4];
- } DATA;
-} sc_rpc_msg_t;
-
-typedef enum sc_rpc_async_state_e {
- SC_RPC_ASYNC_STATE_RD_START = 0,
- SC_RPC_ASYNC_STATE_RD_ACTIVE = 1,
- SC_RPC_ASYNC_STATE_RD_DONE = 2,
- SC_RPC_ASYNC_STATE_WR_START = 3,
- SC_RPC_ASYNC_STATE_WR_ACTIVE = 4,
- SC_RPC_ASYNC_STATE_WR_DONE = 5,
-} sc_rpc_async_state_t;
-
-typedef struct sc_rpc_async_msg_s {
- sc_rpc_async_state_t state;
- uint8_t wordIdx;
- sc_rpc_msg_t msg;
- uint32_t timeStamp;
-} sc_rpc_async_msg_t;
-
-/* Functions */
-
-/*!
- * This is an internal function to send an RPC message over an IPC
- * channel. It is called by client-side SCFW API function shims.
- *
- * @param[in] ipc IPC handle
- * @param[in,out] msg handle to a message
- * @param[in] no_resp response flag
- *
- * If \a no_resp is false then this function waits for a response
- * and returns the result in \a msg.
- */
-void sc_call_rpc(sc_ipc_t ipc, sc_rpc_msg_t *msg, bool no_resp);
-
-/*!
- * This is an internal function to dispath an RPC call that has
- * arrived via IPC over an MU. It is called by server-side SCFW.
- *
- * @param[in] mu MU message arrived on
- * @param[in,out] msg handle to a message
- *
- * The function result is returned in \a msg.
- */
-void sc_rpc_dispatch(sc_rsrc_t mu, sc_rpc_msg_t *msg);
-
-/*!
- * This function translates an RPC message and forwards on to the
- * normal RPC API. It is used only by hypervisors.
- *
- * @param[in] ipc IPC handle
- * @param[in,out] msg handle to a message
- *
- * This function decodes a message, calls macros to translate the
- * resources, pins, addresses, partitions, memory regions, etc. and
- * then forwards on to the hypervisors SCFW API.Return results are
- * translated back abd placed back into the message to be returned
- * to the original API.
- */
-void sc_rpc_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
-
-#endif /* _SC_RPC_H */
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * Header file for the IRQ RPC implementation.
- *
- * @addtogroup IRQ_SVC
- * @{
- */
-
-#ifndef _SC_IRQ_RPC_H
-#define _SC_IRQ_RPC_H
-
-/* Includes */
-
-/* Defines */
-
-/* Types */
-
-/*!
- * This type is used to indicate RPC IRQ function calls.
- */
-typedef enum irq_func_e {
- IRQ_FUNC_UNKNOWN, /* Unknown function */
- IRQ_FUNC_ENABLE, /* Index for irq_enable() RPC call */
- IRQ_FUNC_STATUS, /* Index for irq_status() RPC call */
-} irq_func_t;
-
-/* Functions */
-
-/*!
- * This function dispatches an incoming IRQ RPC request.
- *
- * @param[in] caller_pt caller partition
- * @param[in] msg pointer to RPC message
- */
-void irq_dispatch(sc_rm_pt_t caller_pt, sc_rpc_msg_t *msg);
-
-/*!
- * This function translates and dispatches an IRQ RPC request.
- *
- * @param[in] ipc IPC handle
- * @param[in] msg pointer to RPC message
- */
-void irq_xlate(sc_ipc_t ipc, sc_rpc_msg_t *msg);
-
-#endif /* _SC_IRQ_RPC_H */
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * File containing client-side RPC functions for the IRQ service. These
- * function are ported to clients that communicate to the SC.
- *
- * @addtogroup IRQ_SVC
- * @{
- */
-
-/* Includes */
-
-#include <soc/imx8/sc/types.h>
-#include <soc/imx8/sc/svc/rm/api.h>
-#include <soc/imx8/sc/svc/irq/api.h>
-#include "../../main/rpc.h"
-#include "rpc.h"
-
-/* Local Defines */
-
-/* Local Types */
-
-/* Local Functions */
-
-sc_err_t sc_irq_enable(sc_ipc_t ipc, sc_rsrc_t resource,
- sc_irq_group_t group, uint32_t mask, bool enable)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_IRQ;
- RPC_FUNC(&msg) = IRQ_FUNC_ENABLE;
- RPC_D32(&msg, 0) = mask;
- RPC_D16(&msg, 4) = resource;
- RPC_D8(&msg, 6) = group;
- RPC_D8(&msg, 7) = enable;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_irq_status(sc_ipc_t ipc, sc_rsrc_t resource,
- sc_irq_group_t group, uint32_t *status)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_IRQ;
- RPC_FUNC(&msg) = IRQ_FUNC_STATUS;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = group;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (status != NULL)
- *status = RPC_D32(&msg, 0);
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * Header file for the MISC RPC implementation.
- *
- * @addtogroup MISC_SVC
- * @{
- */
-
-#ifndef _SC_MISC_RPC_H
-#define _SC_MISC_RPC_H
-
-/* Includes */
-
-/* Defines */
-
-/* Types */
-
-/*!
- * This type is used to indicate RPC MISC function calls.
- */
-typedef enum misc_func_e {
- MISC_FUNC_UNKNOWN, /* Unknown function */
- MISC_FUNC_SET_CONTROL, /* Index for misc_set_control() RPC call */
- MISC_FUNC_GET_CONTROL, /* Index for misc_get_control() RPC call */
- MISC_FUNC_SET_ARI, /* Index for misc_set_ari() RPC call */
- MISC_FUNC_SET_MAX_DMA_GROUP, /* Index for misc_set_max_dma_group() RPC call */
- MISC_FUNC_SET_DMA_GROUP, /* Index for misc_set_dma_group() RPC call */
- MISC_FUNC_WAVEFORM_CAPTURE, /* Index for misc_waveform_capture() RPC call */
- MISC_FUNC_BOOT_STATUS, /* Index for misc_boot_status() RPC call */
- MISC_FUNC_SECO_IMAGE_LOAD, /* Index for misc_seco_image_load() RPC call */
- MISC_FUNC_SECO_AUTHENTICATE, /* Index for misc_seco_authenticate() RPC call */
-} misc_func_t;
-
-/* 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 */
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * File containing client-side RPC functions for the MISC service. These
- * function are ported to clients that communicate to the SC.
- *
- * @addtogroup MISC_SVC
- * @{
- */
-
-/* Includes */
-
-#include <soc/imx8/sc/types.h>
-#include <soc/imx8/sc/svc/rm/api.h>
-#include <soc/imx8/sc/svc/misc/api.h>
-#include "../../main/rpc.h"
-#include "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) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_SET_CONTROL;
- RPC_D32(&msg, 0) = ctrl;
- RPC_D32(&msg, 4) = val;
- RPC_D16(&msg, 8) = resource;
- RPC_SIZE(&msg) = 4;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_GET_CONTROL;
- RPC_D32(&msg, 0) = ctrl;
- RPC_D16(&msg, 4) = resource;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (val != NULL)
- *val = RPC_D32(&msg, 0);
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_misc_set_ari(sc_ipc_t ipc, sc_rsrc_t resource,
- sc_rsrc_t resource_mst, uint16_t ari, bool enable)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_SET_ARI;
- RPC_D16(&msg, 0) = resource;
- RPC_D16(&msg, 2) = resource_mst;
- RPC_D16(&msg, 4) = ari;
- RPC_D8(&msg, 6) = enable;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- 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) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_SET_MAX_DMA_GROUP;
- RPC_D8(&msg, 0) = pt;
- RPC_D8(&msg, 1) = max;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_SET_DMA_GROUP;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = group;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_misc_waveform_capture(sc_ipc_t ipc, bool enable)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_WAVEFORM_CAPTURE;
- RPC_D8(&msg, 0) = enable;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_BOOT_STATUS;
- RPC_D8(&msg, 0) = status;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, true);
-}
-
-sc_err_t sc_misc_seco_image_load(sc_ipc_t ipc, uint32_t addr_src,
- uint32_t addr_dst, uint32_t len, bool fw)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_SECO_IMAGE_LOAD;
- RPC_D32(&msg, 0) = addr_src;
- RPC_D32(&msg, 4) = addr_dst;
- RPC_D32(&msg, 8) = len;
- RPC_D8(&msg, 12) = fw;
- RPC_SIZE(&msg) = 5;
-
- sc_call_rpc(ipc, &msg, 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,
- uint32_t addr_meta)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_MISC;
- RPC_FUNC(&msg) = MISC_FUNC_SECO_AUTHENTICATE;
- RPC_D32(&msg, 0) = addr_meta;
- RPC_D8(&msg, 4) = cmd;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * Header file for the PAD RPC implementation.
- *
- * @addtogroup PAD_SVC
- * @{
- */
-
-#ifndef _SC_PAD_RPC_H
-#define _SC_PAD_RPC_H
-
-/* Includes */
-
-/* Defines */
-
-/* Types */
-
-/*!
- * This type is used to indicate RPC PAD function calls.
- */
-typedef enum pad_func_e {
- PAD_FUNC_UNKNOWN, /* Unknown function */
- PAD_FUNC_SET_MUX, /* Index for pad_set_mux() RPC call */
- PAD_FUNC_SET_GP, /* Index for pad_set_gp() RPC call */
- PAD_FUNC_SET_GP_28LPP, /* Index for pad_set_gp_28lpp() RPC call */
- PAD_FUNC_SET_WAKEUP, /* Index for pad_set_wakeup() RPC call */
- PAD_FUNC_SET_ALL, /* Index for pad_set_all() RPC call */
- PAD_FUNC_GET_MUX, /* Index for pad_get_mux() RPC call */
- PAD_FUNC_GET_GP, /* Index for pad_get_gp() RPC call */
- PAD_FUNC_GET_GP_28LPP, /* Index for pad_get_gp_28lpp() RPC call */
- PAD_FUNC_GET_WAKEUP, /* Index for pad_get_wakeup() RPC call */
- PAD_FUNC_GET_ALL, /* Index for pad_get_all() RPC call */
- PAD_FUNC_SET_GP_28FDSOI, /* Index for pad_set_gp_28fdsoi() RPC call */
- PAD_FUNC_GET_GP_28FDSOI, /* Index for pad_get_gp_28fdsoi() RPC call */
- PAD_FUNC_SET_GP_28FDSOI_COMP, /* Index for pad_set_gp_28fdsoi_comp() RPC call */
- PAD_FUNC_GET_GP_28FDSOI_COMP, /* Index for pad_get_gp_28fdsoi_comp() RPC call */
- PAD_FUNC_SET, /* Index for pad_set() RPC call */
- PAD_FUNC_GET, /* Index for pad_get() RPC call */
-} pad_func_t;
-
-/* 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 /* _SC_PAD_RPC_H */
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * File containing client-side RPC functions for the PAD service. These
- * function are ported to clients that communicate to the SC.
- *
- * @addtogroup PAD_SVC
- * @{
- */
-
-/* Includes */
-
-#include <soc/imx8/sc/types.h>
-#include <soc/imx8/sc/svc/rm/api.h>
-#include <soc/imx8/sc/svc/pad/api.h>
-#include "../../main/rpc.h"
-#include "rpc.h"
-
-/* Local Defines */
-
-/* Local Types */
-
-/* Local Functions */
-
-sc_err_t sc_pad_set_mux(sc_ipc_t ipc, sc_pin_t pin,
- 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) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET_MUX;
- RPC_D16(&msg, 0) = pin;
- RPC_D8(&msg, 2) = mux;
- RPC_D8(&msg, 3) = config;
- RPC_D8(&msg, 4) = iso;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_set_gp(sc_ipc_t ipc, sc_pin_t pin, uint32_t ctrl)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET_GP;
- RPC_D32(&msg, 0) = ctrl;
- RPC_D16(&msg, 4) = pin;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_set_gp_28lpp(sc_ipc_t ipc, sc_pin_t pin,
- sc_pad_28lpp_dse_t dse, bool sre, bool hys,
- bool pe, sc_pad_28lpp_ps_t ps)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET_GP_28LPP;
- RPC_D16(&msg, 0) = pin;
- RPC_D8(&msg, 2) = dse;
- RPC_D8(&msg, 3) = ps;
- RPC_D8(&msg, 4) = sre;
- RPC_D8(&msg, 5) = hys;
- RPC_D8(&msg, 6) = pe;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_set_wakeup(sc_ipc_t ipc, sc_pin_t pin, sc_pad_wakeup_t wakeup)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET_WAKEUP;
- RPC_D16(&msg, 0) = pin;
- RPC_D8(&msg, 2) = wakeup;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_set_all(sc_ipc_t ipc, sc_pin_t pin, 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) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET_ALL;
- RPC_D32(&msg, 0) = ctrl;
- RPC_D16(&msg, 4) = pin;
- RPC_D8(&msg, 6) = mux;
- RPC_D8(&msg, 7) = config;
- RPC_D8(&msg, 8) = iso;
- RPC_D8(&msg, 9) = wakeup;
- RPC_SIZE(&msg) = 4;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get_mux(sc_ipc_t ipc, sc_pin_t pin,
- 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) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET_MUX;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (mux != NULL)
- *mux = RPC_D8(&msg, 0);
- if (config != NULL)
- *config = RPC_D8(&msg, 1);
- if (iso != NULL)
- *iso = RPC_D8(&msg, 2);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get_gp(sc_ipc_t ipc, sc_pin_t pin, uint32_t *ctrl)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET_GP;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (ctrl != NULL)
- *ctrl = RPC_D32(&msg, 0);
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get_gp_28lpp(sc_ipc_t ipc, sc_pin_t pin,
- sc_pad_28lpp_dse_t *dse, bool *sre, bool *hys,
- bool *pe, sc_pad_28lpp_ps_t *ps)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET_GP_28LPP;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (dse != NULL)
- *dse = RPC_D8(&msg, 0);
- if (ps != NULL)
- *ps = RPC_D8(&msg, 1);
- if (sre != NULL)
- *sre = RPC_D8(&msg, 2);
- if (hys != NULL)
- *hys = RPC_D8(&msg, 3);
- if (pe != NULL)
- *pe = RPC_D8(&msg, 4);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get_wakeup(sc_ipc_t ipc, sc_pin_t pin, sc_pad_wakeup_t *wakeup)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET_WAKEUP;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (wakeup != NULL)
- *wakeup = RPC_D8(&msg, 0);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get_all(sc_ipc_t ipc, sc_pin_t pin, 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) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET_ALL;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (ctrl != NULL)
- *ctrl = RPC_D32(&msg, 0);
- result = RPC_R8(&msg);
- if (mux != NULL)
- *mux = RPC_D8(&msg, 4);
- if (config != NULL)
- *config = RPC_D8(&msg, 5);
- if (iso != NULL)
- *iso = RPC_D8(&msg, 6);
- if (wakeup != NULL)
- *wakeup = RPC_D8(&msg, 7);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_set_gp_28fdsoi(sc_ipc_t ipc, sc_pin_t pin,
- 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) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET_GP_28FDSOI;
- RPC_D16(&msg, 0) = pin;
- RPC_D8(&msg, 2) = dse;
- RPC_D8(&msg, 3) = ps;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get_gp_28fdsoi(sc_ipc_t ipc, sc_pin_t pin,
- 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) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET_GP_28FDSOI;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (dse != NULL)
- *dse = RPC_D8(&msg, 0);
- if (ps != NULL)
- *ps = RPC_D8(&msg, 1);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_set_gp_28fdsoi_comp(sc_ipc_t ipc, sc_pin_t pin,
- uint8_t compen, bool fastfrz,
- uint8_t rasrcp, uint8_t rasrcn,
- bool nasrc_sel)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET_GP_28FDSOI_COMP;
- RPC_D16(&msg, 0) = pin;
- RPC_D8(&msg, 2) = compen;
- RPC_D8(&msg, 3) = rasrcp;
- RPC_D8(&msg, 4) = rasrcn;
- RPC_D8(&msg, 5) = fastfrz;
- RPC_D8(&msg, 6) = nasrc_sel;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get_gp_28fdsoi_comp(sc_ipc_t ipc, sc_pin_t pin,
- uint8_t *compen, bool *fastfrz,
- uint8_t *rasrcp, uint8_t *rasrcn,
- bool *nasrc_sel, bool *compok,
- uint8_t *nasrc)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET_GP_28FDSOI_COMP;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (compen != NULL)
- *compen = RPC_D8(&msg, 0);
- if (rasrcp != NULL)
- *rasrcp = RPC_D8(&msg, 1);
- if (rasrcn != NULL)
- *rasrcn = RPC_D8(&msg, 2);
- if (nasrc != NULL)
- *nasrc = RPC_D8(&msg, 3);
- if (fastfrz != NULL)
- *fastfrz = RPC_D8(&msg, 4);
- if (nasrc_sel != NULL)
- *nasrc_sel = RPC_D8(&msg, 5);
- if (compok != NULL)
- *compok = RPC_D8(&msg, 6);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_set(sc_ipc_t ipc, sc_pin_t pin, uint32_t val)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_SET;
- RPC_D32(&msg, 0) = val;
- RPC_D16(&msg, 4) = pin;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pad_get(sc_ipc_t ipc, sc_pin_t pin, uint32_t *val)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PAD;
- RPC_FUNC(&msg) = PAD_FUNC_GET;
- RPC_D16(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (val != NULL)
- *val = RPC_D32(&msg, 0);
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * Header file for the PM RPC implementation.
- *
- * @addtogroup PM_SVC
- * @{
- */
-
-#ifndef _SC_PM_RPC_H
-#define _SC_PM_RPC_H
-
-/* Includes */
-
-/* Defines */
-
-/* Types */
-
-/*!
- * This type is used to indicate RPC PM function calls.
- */
-typedef enum pm_func_e {
- PM_FUNC_UNKNOWN, /* Unknown function */
- PM_FUNC_SET_SYS_POWER_MODE, /* Index for pm_set_sys_power_mode() RPC call */
- PM_FUNC_GET_SYS_POWER_MODE, /* Index for pm_get_sys_power_mode() RPC call */
- PM_FUNC_SET_RESOURCE_POWER_MODE, /* Index for pm_set_resource_power_mode() RPC call */
- PM_FUNC_GET_RESOURCE_POWER_MODE, /* Index for pm_get_resource_power_mode() RPC call */
- PM_FUNC_SET_CLOCK_RATE, /* Index for pm_set_clock_rate() RPC call */
- PM_FUNC_GET_CLOCK_RATE, /* Index for pm_get_clock_rate() RPC call */
- PM_FUNC_CLOCK_ENABLE, /* Index for pm_clock_enable() RPC call */
- PM_FUNC_BOOT, /* Index for pm_boot() RPC call */
- PM_FUNC_REBOOT, /* Index for pm_reboot() RPC call */
- PM_FUNC_RESET_REASON, /* Index for pm_reset_reason() RPC call */
- PM_FUNC_CPU_START, /* Index for pm_cpu_start() RPC call */
- PM_FUNC_REBOOT_PARTITION, /* Index for pm_reboot_partition() RPC call */
- PM_FUNC_RESET, /* Index for pm_reset() RPC call */
-} pm_func_t;
-
-/* 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 /* _SC_PM_RPC_H */
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * File containing client-side RPC functions for the PM service. These
- * function are ported to clients that communicate to the SC.
- *
- * @addtogroup PM_SVC
- * @{
- */
-
-/* Includes */
-
-#include <soc/imx8/sc/types.h>
-#include <soc/imx8/sc/svc/rm/api.h>
-#include <soc/imx8/sc/svc/pm/api.h>
-#include "../../main/rpc.h"
-#include "rpc.h"
-
-/* Local Defines */
-
-/* Local Types */
-
-/* Local Functions */
-
-sc_err_t sc_pm_set_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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_SET_SYS_POWER_MODE;
- RPC_D8(&msg, 0) = pt;
- RPC_D8(&msg, 1) = mode;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_GET_SYS_POWER_MODE;
- RPC_D8(&msg, 0) = pt;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (mode != NULL)
- *mode = RPC_D8(&msg, 0);
- 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_SET_RESOURCE_POWER_MODE;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = mode;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_GET_RESOURCE_POWER_MODE;
- RPC_D16(&msg, 0) = resource;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (mode != NULL)
- *mode = RPC_D8(&msg, 0);
- 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_SET_CLOCK_RATE;
- RPC_D32(&msg, 0) = *rate;
- RPC_D16(&msg, 4) = resource;
- RPC_D8(&msg, 6) = clk;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- *rate = RPC_D32(&msg, 0);
- 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_GET_CLOCK_RATE;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = clk;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (rate != NULL)
- *rate = RPC_D32(&msg, 0);
- 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, bool enable, bool autog)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_CLOCK_ENABLE;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = clk;
- RPC_D8(&msg, 3) = enable;
- RPC_D8(&msg, 4) = autog;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_BOOT;
- RPC_D32(&msg, 0) = boot_addr >> 32;
- RPC_D32(&msg, 4) = boot_addr;
- RPC_D16(&msg, 8) = resource_cpu;
- RPC_D16(&msg, 10) = resource_mu;
- RPC_D16(&msg, 12) = resource_dev;
- RPC_D8(&msg, 14) = pt;
- RPC_SIZE(&msg) = 5;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_REBOOT;
- RPC_D8(&msg, 0) = type;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, true);
-}
-
-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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_RESET_REASON;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (reason != NULL)
- *reason = RPC_D8(&msg, 0);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_pm_cpu_start(sc_ipc_t ipc, sc_rsrc_t resource, bool enable,
- sc_faddr_t address)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_CPU_START;
- RPC_D32(&msg, 0) = address >> 32;
- RPC_D32(&msg, 4) = address;
- RPC_D16(&msg, 8) = resource;
- RPC_D8(&msg, 10) = enable;
- RPC_SIZE(&msg) = 4;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_REBOOT_PARTITION;
- RPC_D8(&msg, 0) = pt;
- RPC_D8(&msg, 1) = type;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- 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) = SC_RPC_SVC_PM;
- RPC_FUNC(&msg) = PM_FUNC_RESET;
- RPC_D8(&msg, 0) = type;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * Header file for the RM RPC implementation.
- *
- * @addtogroup RM_SVC
- * @{
- */
-
-#ifndef _SC_RM_RPC_H
-#define _SC_RM_RPC_H
-
-/* Includes */
-
-/* Defines */
-
-/* Types */
-
-/*!
- * This type is used to indicate RPC RM function calls.
- */
-typedef enum rm_func_e {
- RM_FUNC_UNKNOWN, /* Unknown function */
- RM_FUNC_PARTITION_ALLOC, /* Index for rm_partition_alloc() RPC call */
- RM_FUNC_PARTITION_FREE, /* Index for rm_partition_free() RPC call */
- RM_FUNC_PARTITION_STATIC, /* Index for rm_partition_static() RPC call */
- RM_FUNC_PARTITION_LOCK, /* Index for rm_partition_lock() RPC call */
- RM_FUNC_GET_PARTITION, /* Index for rm_get_partition() RPC call */
- RM_FUNC_SET_PARENT, /* Index for rm_set_parent() RPC call */
- RM_FUNC_MOVE_ALL, /* Index for rm_move_all() RPC call */
- RM_FUNC_ASSIGN_RESOURCE, /* Index for rm_assign_resource() RPC call */
- RM_FUNC_SET_RESOURCE_MOVABLE, /* Index for rm_set_resource_movable() RPC call */
- RM_FUNC_SET_MASTER_ATTRIBUTES, /* Index for rm_set_master_attributes() RPC call */
- RM_FUNC_SET_MASTER_SID, /* Index for rm_set_master_sid() RPC call */
- RM_FUNC_SET_PERIPHERAL_PERMISSIONS, /* Index for rm_set_peripheral_permissions() RPC call */
- RM_FUNC_IS_RESOURCE_OWNED, /* Index for rm_is_resource_owned() RPC call */
- RM_FUNC_IS_RESOURCE_MASTER, /* Index for rm_is_resource_master() RPC call */
- RM_FUNC_IS_RESOURCE_PERIPHERAL, /* Index for rm_is_resource_peripheral() RPC call */
- RM_FUNC_GET_RESOURCE_INFO, /* Index for rm_get_resource_info() RPC call */
- RM_FUNC_MEMREG_ALLOC, /* Index for rm_memreg_alloc() RPC call */
- RM_FUNC_MEMREG_FREE, /* Index for rm_memreg_free() RPC call */
- RM_FUNC_ASSIGN_MEMREG, /* Index for rm_assign_memreg() RPC call */
- RM_FUNC_SET_MEMREG_PERMISSIONS, /* Index for rm_set_memreg_permissions() RPC call */
- RM_FUNC_IS_MEMREG_OWNED, /* Index for rm_is_memreg_owned() RPC call */
- RM_FUNC_GET_MEMREG_INFO, /* Index for rm_get_memreg_info() RPC call */
- RM_FUNC_ASSIGN_PIN, /* Index for rm_assign_pin() RPC call */
- RM_FUNC_SET_PIN_MOVABLE, /* Index for rm_set_pin_movable() RPC call */
- RM_FUNC_IS_PIN_OWNED, /* Index for rm_is_pin_owned() RPC call */
- RM_FUNC_GET_DID, /* Index for rm_get_did() RPC call */
-} rm_func_t;
-
-/* 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 /* _SC_RM_RPC_H */
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * File containing client-side RPC functions for the RM service. These
- * function are ported to clients that communicate to the SC.
- *
- * @addtogroup RM_SVC
- * @{
- */
-
-/* Includes */
-
-#include <soc/imx8/sc/types.h>
-#include <soc/imx8/sc/svc/rm/api.h>
-#include "../../main/rpc.h"
-#include "rpc.h"
-
-/* Local Defines */
-
-/* Local Types */
-
-/* Local Functions */
-
-sc_err_t sc_rm_partition_alloc(sc_ipc_t ipc, sc_rm_pt_t *pt, bool secure,
- bool isolated, bool restricted,
- bool confidential, bool coherent)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_PARTITION_ALLOC;
- RPC_D8(&msg, 0) = secure;
- RPC_D8(&msg, 1) = isolated;
- RPC_D8(&msg, 2) = restricted;
- RPC_D8(&msg, 3) = confidential;
- RPC_D8(&msg, 4) = coherent;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (pt != NULL)
- *pt = RPC_D8(&msg, 0);
- 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_PARTITION_FREE;
- RPC_D8(&msg, 0) = pt;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_GET_DID;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_PARTITION_STATIC;
- RPC_D8(&msg, 0) = pt;
- RPC_D8(&msg, 1) = did;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_PARTITION_LOCK;
- RPC_D8(&msg, 0) = pt;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_GET_PARTITION;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (pt != NULL)
- *pt = RPC_D8(&msg, 0);
- 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_SET_PARENT;
- RPC_D8(&msg, 0) = pt;
- RPC_D8(&msg, 1) = pt_parent;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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,
- bool move_rsrc, bool move_pins)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_MOVE_ALL;
- RPC_D8(&msg, 0) = pt_src;
- RPC_D8(&msg, 1) = pt_dst;
- RPC_D8(&msg, 2) = move_rsrc;
- RPC_D8(&msg, 3) = move_pins;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_ASSIGN_RESOURCE;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = pt;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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, bool movable)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_SET_RESOURCE_MOVABLE;
- RPC_D16(&msg, 0) = resource_fst;
- RPC_D16(&msg, 2) = resource_lst;
- RPC_D8(&msg, 4) = movable;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, 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,
- bool smmu_bypass)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_SET_MASTER_ATTRIBUTES;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = sa;
- RPC_D8(&msg, 3) = pa;
- RPC_D8(&msg, 4) = smmu_bypass;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_SET_MASTER_SID;
- RPC_D16(&msg, 0) = resource;
- RPC_D16(&msg, 2) = sid;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_SET_PERIPHERAL_PERMISSIONS;
- RPC_D16(&msg, 0) = resource;
- RPC_D8(&msg, 2) = pt;
- RPC_D8(&msg, 3) = perm;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-bool 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_OWNED;
- RPC_D16(&msg, 0) = resource;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (bool) result;
-}
-
-bool 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_MASTER;
- RPC_D16(&msg, 0) = resource;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (bool) result;
-}
-
-bool 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_IS_RESOURCE_PERIPHERAL;
- RPC_D16(&msg, 0) = resource;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (bool) 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_GET_RESOURCE_INFO;
- RPC_D16(&msg, 0) = resource;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (sid != NULL)
- *sid = RPC_D16(&msg, 0);
- 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_MEMREG_ALLOC;
- RPC_D32(&msg, 0) = addr_start >> 32;
- RPC_D32(&msg, 4) = addr_start;
- RPC_D32(&msg, 8) = addr_end >> 32;
- RPC_D32(&msg, 12) = addr_end;
- RPC_SIZE(&msg) = 5;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- if (mr != NULL)
- *mr = RPC_D8(&msg, 0);
- 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_MEMREG_FREE;
- RPC_D8(&msg, 0) = mr;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_ASSIGN_MEMREG;
- RPC_D8(&msg, 0) = pt;
- RPC_D8(&msg, 1) = mr;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_SET_MEMREG_PERMISSIONS;
- RPC_D8(&msg, 0) = mr;
- RPC_D8(&msg, 1) = pt;
- RPC_D8(&msg, 2) = perm;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-bool 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_IS_MEMREG_OWNED;
- RPC_D8(&msg, 0) = mr;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (bool) 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) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_GET_MEMREG_INFO;
- RPC_D8(&msg, 0) = mr;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (addr_start != NULL)
- *addr_start =
- ((uint64_t) RPC_D32(&msg, 0) << 32) | RPC_D32(&msg, 4);
- if (addr_end != NULL)
- *addr_end =
- ((uint64_t) RPC_D32(&msg, 8) << 32) | RPC_D32(&msg, 12);
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_rm_assign_pin(sc_ipc_t ipc, sc_rm_pt_t pt, sc_pin_t pin)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_ASSIGN_PIN;
- RPC_D16(&msg, 0) = pin;
- RPC_D8(&msg, 2) = pt;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_rm_set_pin_movable(sc_ipc_t ipc, sc_pin_t pin_fst,
- sc_pin_t pin_lst, bool movable)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_SET_PIN_MOVABLE;
- RPC_D16(&msg, 0) = pin_fst;
- RPC_D16(&msg, 2) = pin_lst;
- RPC_D8(&msg, 4) = movable;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-bool sc_rm_is_pin_owned(sc_ipc_t ipc, sc_pin_t pin)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_RM;
- RPC_FUNC(&msg) = RM_FUNC_IS_PIN_OWNED;
- RPC_D8(&msg, 0) = pin;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (bool) result;
-}
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * Header file for the TIMER RPC implementation.
- *
- * @addtogroup TIMER_SVC
- * @{
- */
-
-#ifndef _SC_TIMER_RPC_H
-#define _SC_TIMER_RPC_H
-
-/* Includes */
-
-/* Defines */
-
-/* Types */
-
-/*!
- * This type is used to indicate RPC TIMER function calls.
- */
-typedef enum timer_func_e {
- TIMER_FUNC_UNKNOWN, /* Unknown function */
- TIMER_FUNC_SET_WDOG_TIMEOUT, /* Index for timer_set_wdog_timeout() RPC call */
- TIMER_FUNC_START_WDOG, /* Index for timer_start_wdog() RPC call */
- TIMER_FUNC_STOP_WDOG, /* Index for timer_stop_wdog() RPC call */
- TIMER_FUNC_PING_WDOG, /* Index for timer_ping_wdog() RPC call */
- TIMER_FUNC_GET_WDOG_STATUS, /* Index for timer_get_wdog_status() RPC call */
- TIMER_FUNC_SET_RTC_TIME, /* Index for timer_set_rtc_time() RPC call */
- TIMER_FUNC_GET_RTC_TIME, /* Index for timer_get_rtc_time() RPC call */
- TIMER_FUNC_SET_RTC_ALARM, /* Index for timer_set_rtc_alarm() RPC call */
- TIMER_FUNC_GET_RTC_SEC1970, /* Index for timer_get_rtc_sec1970() RPC call */
-} timer_func_t;
-
-/* 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 */
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * SPDX-License-Identifier: GPL-2.0+
- */
-
-/*!
- * File containing client-side RPC functions for the TIMER service. These
- * function are ported to clients that communicate to the SC.
- *
- * @addtogroup TIMER_SVC
- * @{
- */
-
-/* Includes */
-
-#include <soc/imx8/sc/types.h>
-#include <soc/imx8/sc/svc/rm/api.h>
-#include <soc/imx8/sc/svc/timer/api.h>
-#include "../../main/rpc.h"
-#include "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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_SET_WDOG_TIMEOUT;
- RPC_D32(&msg, 0) = timeout;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-sc_err_t sc_timer_start_wdog(sc_ipc_t ipc, bool lock)
-{
- sc_rpc_msg_t msg;
- uint8_t result;
-
- RPC_VER(&msg) = SC_RPC_VERSION;
- RPC_SVC(&msg) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_START_WDOG;
- RPC_D8(&msg, 0) = lock;
- RPC_SIZE(&msg) = 2;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_STOP_WDOG;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_PING_WDOG;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_GET_WDOG_STATUS;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (timeout != NULL)
- *timeout = RPC_D32(&msg, 0);
- if (max_timeout != NULL)
- *max_timeout = RPC_D32(&msg, 4);
- if (remaining_time != NULL)
- *remaining_time = RPC_D32(&msg, 8);
- 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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_SET_RTC_TIME;
- RPC_D16(&msg, 0) = year;
- RPC_D8(&msg, 2) = mon;
- RPC_D8(&msg, 3) = day;
- RPC_D8(&msg, 4) = hour;
- RPC_D8(&msg, 5) = min;
- RPC_D8(&msg, 6) = sec;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, 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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_GET_RTC_TIME;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (year != NULL)
- *year = RPC_D16(&msg, 0);
- result = RPC_R8(&msg);
- if (mon != NULL)
- *mon = RPC_D8(&msg, 2);
- if (day != NULL)
- *day = RPC_D8(&msg, 3);
- if (hour != NULL)
- *hour = RPC_D8(&msg, 4);
- if (min != NULL)
- *min = RPC_D8(&msg, 5);
- if (sec != NULL)
- *sec = RPC_D8(&msg, 6);
- 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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_SET_RTC_ALARM;
- RPC_D16(&msg, 0) = year;
- RPC_D8(&msg, 2) = mon;
- RPC_D8(&msg, 3) = day;
- RPC_D8(&msg, 4) = hour;
- RPC_D8(&msg, 5) = min;
- RPC_D8(&msg, 6) = sec;
- RPC_SIZE(&msg) = 3;
-
- sc_call_rpc(ipc, &msg, false);
-
- result = RPC_R8(&msg);
- 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) = SC_RPC_SVC_TIMER;
- RPC_FUNC(&msg) = TIMER_FUNC_GET_RTC_SEC1970;
- RPC_SIZE(&msg) = 1;
-
- sc_call_rpc(ipc, &msg, false);
-
- if (sec != NULL)
- *sec = RPC_D32(&msg, 0);
- result = RPC_R8(&msg);
- return (sc_err_t) result;
-}
-
-/**@}*/
+++ /dev/null
-/*
- * Copyright (C) 2016 Freescale Semiconductor, Inc.
- * Copyright 2017 NXP
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-
-#include <linux/init.h>
-#include <linux/io.h>
-#include <linux/slab.h>
-#include <linux/sys_soc.h>
-#include <linux/platform_device.h>
-#include <linux/of.h>
-
-struct imx8_soc_data {
- char *name;
- u32 (*soc_revision)(void);
-};
-
-u32 imx8qm_soc_revision(void);
-u32 imx8qxp_soc_revision(void);
-
-struct imx8_soc_data imx8qm_soc_data = {
- .name = "i.MX8QM",
- .soc_revision = imx8qm_soc_revision,
-};
-
-struct imx8_soc_data imx8qxp_soc_data = {
- .name = "i.MX8QXP",
- .soc_revision = imx8qxp_soc_revision,
-};
-
-static const struct of_device_id imx8_soc_match[] = {
- { .compatible = "fsl,imx8qm", .data = &imx8qm_soc_data, },
- { .compatible = "fsl,imx8qxp", .data = &imx8qxp_soc_data, },
- { }
-};
-
-u32 imx8qm_soc_revision(void)
-{
- /*FIX ME later */
-
- return 0x10;
-}
-
-u32 imx8qxp_soc_revision(void)
-{
- /*FIX ME later */
-
- return 0x10;
-}
-
-static int __init imx8_soc_init(void)
-{
- struct soc_device_attribute *soc_dev_attr;
- struct soc_device *soc_dev;
- struct device_node *root;
- const struct of_device_id *id;
- u32 imx_soc_revision = 0;
- const struct imx8_soc_data *data;
- int ret;
-
- soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
- if (!soc_dev_attr)
- return -ENODEV;
-
- soc_dev_attr->family = "Freescale i.MX";
-
- root = of_find_node_by_path("/");
- ret = of_property_read_string(root, "model", &soc_dev_attr->machine);
- if (ret)
- goto free_soc;
-
- id = of_match_node(imx8_soc_match, root);
- if (!id)
- goto free_soc;
-
- of_node_put(root);
-
- data = id->data;
- if (data) {
- soc_dev_attr->soc_id = data->name;
- if (data->soc_revision)
- imx_soc_revision = data->soc_revision();
- }
-
- soc_dev_attr->revision = kasprintf(GFP_KERNEL, "%d.%d",
- (imx_soc_revision >> 4) & 0xf,
- imx_soc_revision & 0xf);
- if (!soc_dev_attr->revision)
- goto free_soc;
-
- soc_dev = soc_device_register(soc_dev_attr);
- if (IS_ERR(soc_dev))
- goto free_rev;
-
- return 0;
-
-free_rev:
- kfree(soc_dev_attr->revision);
-free_soc:
- kfree(soc_dev_attr);
- return -ENODEV;
-}
-device_initcall(imx8_soc_init);
projects / linux.git / commitdiff