lkml.org 
[lkml]   [2020]   [Jan]   [5]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Date
From
SubjectRe: [PATCH v4 16/17] firmware: qcom_scm: Remove thin wrappers
On Thu, Dec 12, 2019 at 06:51:24PM +0000, Elliot Berman wrote:
> qcom_scm-32 and qcom_scm-64 implementations are nearly identical, so
> make qcom_scm_call and qcom_scm_call_atomic unique to each and the SCM
> descriptor creation common to each. There are the following catches:
> - __qcom_scm_is_call_available is still in each -32,-64 implementation
> as the argument is unique to each convention
> - For some functions, only one implementation was provided in -32 or
> -64. The actual implementation was moved into qcom_scm.c
> - io_writel and io_readl in -64 were non-atomic calls and in -32 they
> were. Atomic is the better option, so use it.
>
> Signed-off-by: Elliot Berman <eberman@codeaurora.org>
> ---
> drivers/firmware/qcom_scm-32.c | 461 +----------------------------------------
> drivers/firmware/qcom_scm-64.c | 434 +-------------------------------------
> drivers/firmware/qcom_scm.c | 392 ++++++++++++++++++++++++++++++++---
> drivers/firmware/qcom_scm.h | 87 ++++----
> 4 files changed, 426 insertions(+), 948 deletions(-)
>
<snip>
> diff --git a/drivers/firmware/qcom_scm.c b/drivers/firmware/qcom_scm.c
> index 5ba4c85..b29e6c1 100644
> --- a/drivers/firmware/qcom_scm.c
> +++ b/drivers/firmware/qcom_scm.c
> @@ -16,6 +16,7 @@
> #include <linux/of_platform.h>
> #include <linux/clk.h>
> #include <linux/reset-controller.h>
> +#include <linux/arm-smccc.h>
>
> #include "qcom_scm.h"
>
> @@ -49,6 +50,28 @@ struct qcom_scm_mem_map_info {
> __le64 mem_size;
> };
>
> +#define QCOM_SCM_FLAG_COLDBOOT_CPU0 0x00
> +#define QCOM_SCM_FLAG_COLDBOOT_CPU1 0x01
> +#define QCOM_SCM_FLAG_COLDBOOT_CPU2 0x08
> +#define QCOM_SCM_FLAG_COLDBOOT_CPU3 0x20
> +
> +#define QCOM_SCM_FLAG_WARMBOOT_CPU0 0x04
> +#define QCOM_SCM_FLAG_WARMBOOT_CPU1 0x02
> +#define QCOM_SCM_FLAG_WARMBOOT_CPU2 0x10
> +#define QCOM_SCM_FLAG_WARMBOOT_CPU3 0x40
> +
> +struct qcom_scm_wb_entry {
> + int flag;
> + void *entry;
> +};
> +
> +static struct qcom_scm_wb_entry qcom_scm_wb[] = {
> + { .flag = QCOM_SCM_FLAG_WARMBOOT_CPU0 },
> + { .flag = QCOM_SCM_FLAG_WARMBOOT_CPU1 },
> + { .flag = QCOM_SCM_FLAG_WARMBOOT_CPU2 },
> + { .flag = QCOM_SCM_FLAG_WARMBOOT_CPU3 },
> +};
> +
> static struct qcom_scm *__scm;
>
> static int qcom_scm_clk_enable(void)
> @@ -94,7 +117,39 @@ static void qcom_scm_clk_disable(void)
> */
> int qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus)
> {
> - return __qcom_scm_set_warm_boot_addr(__scm->dev, entry, cpus);
> + int ret;
> + int flags = 0;
> + int cpu;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_BOOT,
> + .cmd = QCOM_SCM_BOOT_SET_ADDR,
> + .arginfo = QCOM_SCM_ARGS(2),
> + };
> +
> + /*
> + * Reassign only if we are switching from hotplug entry point
> + * to cpuidle entry point or vice versa.
> + */
> + for_each_cpu(cpu, cpus) {
> + if (entry == qcom_scm_wb[cpu].entry)
> + continue;
> + flags |= qcom_scm_wb[cpu].flag;
> + }
> +
> + /* No change in entry function */
> + if (!flags)
> + return 0;
> +
> + desc.args[0] = flags;
> + desc.args[1] = virt_to_phys(entry);
> +
> + ret = qcom_scm_call(__scm->dev, &desc, NULL);
> + if (!ret) {
> + for_each_cpu(cpu, cpus)
> + qcom_scm_wb[cpu].entry = entry;
> + }
> +
> + return ret;
> }
> EXPORT_SYMBOL(qcom_scm_set_warm_boot_addr);
>
> @@ -108,8 +163,35 @@ EXPORT_SYMBOL(qcom_scm_set_warm_boot_addr);
> */
> int qcom_scm_set_cold_boot_addr(void *entry, const cpumask_t *cpus)
> {
> - return __qcom_scm_set_cold_boot_addr(__scm ? __scm->dev : NULL, entry,
> - cpus);
> + int flags = 0;
> + int cpu;
> + int scm_cb_flags[] = {
> + QCOM_SCM_FLAG_COLDBOOT_CPU0,
> + QCOM_SCM_FLAG_COLDBOOT_CPU1,
> + QCOM_SCM_FLAG_COLDBOOT_CPU2,
> + QCOM_SCM_FLAG_COLDBOOT_CPU3,
> + };
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_BOOT,
> + .cmd = QCOM_SCM_BOOT_SET_ADDR,
> + .arginfo = QCOM_SCM_ARGS(2),
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> +
> + if (!cpus || (cpus && cpumask_empty(cpus)))
> + return -EINVAL;
> +
> + for_each_cpu(cpu, cpus) {
> + if (cpu < ARRAY_SIZE(scm_cb_flags))
> + flags |= scm_cb_flags[cpu];
> + else
> + set_cpu_present(cpu, false);
> + }
> +
> + desc.args[0] = flags;
> + desc.args[1] = virt_to_phys(entry);
> +
> + return qcom_scm_call_atomic(__scm ? __scm->dev : NULL, &desc, NULL);
> }
> EXPORT_SYMBOL(qcom_scm_set_cold_boot_addr);
>
> @@ -123,16 +205,52 @@ EXPORT_SYMBOL(qcom_scm_set_cold_boot_addr);
> */
> void qcom_scm_cpu_power_down(u32 flags)
> {
> - __qcom_scm_cpu_power_down(__scm ? __scm->dev : NULL, flags);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_BOOT,
> + .cmd = QCOM_SCM_BOOT_TERMINATE_PC,
> + .args[0] = flags & QCOM_SCM_FLUSH_FLAG_MASK,
> + .arginfo = QCOM_SCM_ARGS(1),
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> +
> + qcom_scm_call_atomic(__scm ? __scm->dev : NULL, &desc, NULL);
> }
> EXPORT_SYMBOL(qcom_scm_cpu_power_down);
>
> int qcom_scm_set_remote_state(u32 state, u32 id)
> {
> - return __qcom_scm_set_remote_state(__scm->dev, state, id);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_BOOT,
> + .cmd = QCOM_SCM_BOOT_SET_REMOTE_STATE,
> + .arginfo = QCOM_SCM_ARGS(2),
> + .args[0] = state,
> + .args[1] = id,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
> + int ret;
> +
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> +
> + return ret ? : res.result[0];
> }
> EXPORT_SYMBOL(qcom_scm_set_remote_state);
>
> +static int __qcom_scm_set_dload_mode(struct device *dev, bool enable)
> +{
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_BOOT,
> + .cmd = QCOM_SCM_BOOT_SET_DLOAD_MODE,
> + .arginfo = QCOM_SCM_ARGS(2),
> + .args[0] = QCOM_SCM_BOOT_SET_DLOAD_MODE,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> +
> + desc.args[1] = enable ? QCOM_SCM_BOOT_SET_DLOAD_MODE : 0;
> +
> + return qcom_scm_call(__scm->dev, &desc, NULL);
> +}
> +
> static void qcom_scm_set_download_mode(bool enable)
> {
> bool avail;
> @@ -144,8 +262,8 @@ static void qcom_scm_set_download_mode(bool enable)
> if (avail) {
> ret = __qcom_scm_set_dload_mode(__scm->dev, enable);
> } else if (__scm->dload_mode_addr) {
> - ret = __qcom_scm_io_writel(__scm->dev, __scm->dload_mode_addr,
> - enable ? QCOM_SCM_BOOT_SET_DLOAD_MODE : 0);
> + ret = qcom_scm_io_writel(__scm->dload_mode_addr,
> + enable ? QCOM_SCM_BOOT_SET_DLOAD_MODE : 0);
> } else {
> dev_err(__scm->dev,
> "No available mechanism for setting download mode\n");
> @@ -172,6 +290,14 @@ int qcom_scm_pas_init_image(u32 peripheral, const void *metadata, size_t size)
> dma_addr_t mdata_phys;
> void *mdata_buf;
> int ret;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_PIL,
> + .cmd = QCOM_SCM_PIL_PAS_INIT_IMAGE,
> + .arginfo = QCOM_SCM_ARGS(2, QCOM_SCM_VAL, QCOM_SCM_RW),
> + .args[0] = peripheral,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
>
> /*
> * During the scm call memory protection will be enabled for the meta
> @@ -190,14 +316,16 @@ int qcom_scm_pas_init_image(u32 peripheral, const void *metadata, size_t size)
> if (ret)
> goto free_metadata;
>
> - ret = __qcom_scm_pas_init_image(__scm->dev, peripheral, mdata_phys);
> + desc.args[1] = mdata_phys;
> +
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
>
> qcom_scm_clk_disable();
>
> free_metadata:
> dma_free_coherent(__scm->dev, size, mdata_buf, mdata_phys);
>
> - return ret;
> + return ret ? : res.result[0];
> }
> EXPORT_SYMBOL(qcom_scm_pas_init_image);
>
> @@ -213,15 +341,25 @@ EXPORT_SYMBOL(qcom_scm_pas_init_image);
> int qcom_scm_pas_mem_setup(u32 peripheral, phys_addr_t addr, phys_addr_t size)
> {
> int ret;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_PIL,
> + .cmd = QCOM_SCM_PIL_PAS_MEM_SETUP,
> + .arginfo = QCOM_SCM_ARGS(3),
> + .args[0] = peripheral,
> + .args[1] = addr,
> + .args[2] = size,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
>
> ret = qcom_scm_clk_enable();
> if (ret)
> return ret;
>
> - ret = __qcom_scm_pas_mem_setup(__scm->dev, peripheral, addr, size);
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> qcom_scm_clk_disable();
>
> - return ret;
> + return ret ? : res.result[0];
> }
> EXPORT_SYMBOL(qcom_scm_pas_mem_setup);
>
> @@ -235,15 +373,21 @@ EXPORT_SYMBOL(qcom_scm_pas_mem_setup);
> int qcom_scm_pas_auth_and_reset(u32 peripheral)
> {
> int ret;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_PIL,
> + .cmd = QCOM_SCM_PIL_PAS_AUTH_AND_RESET,

Here you forgot to add the args:

.arginfo = QCOM_SCM_ARGS(1),
.args[0] = peripheral,

This breaks WCNSS on MSM8916:

remoteproc remoteproc0: a204000.wcnss is available
remoteproc remoteproc0: powering up a204000.wcnss
remoteproc remoteproc0: Booting fw image wcnss.mdt, size 37980
qcom-wcnss-pil a204000.wcnss: failed to authenticate image and release reset
remoteproc remoteproc0: can't start rproc a204000.wcnss: -12


> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
>
> ret = qcom_scm_clk_enable();
> if (ret)
> return ret;
>
> - ret = __qcom_scm_pas_auth_and_reset(__scm->dev, peripheral);
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> qcom_scm_clk_disable();
>
> - return ret;
> + return ret ? : res.result[0];
> }
> EXPORT_SYMBOL(qcom_scm_pas_auth_and_reset);
>
> @@ -256,15 +400,24 @@ EXPORT_SYMBOL(qcom_scm_pas_auth_and_reset);
> int qcom_scm_pas_shutdown(u32 peripheral)
> {
> int ret;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_PIL,
> + .cmd = QCOM_SCM_PIL_PAS_SHUTDOWN,
> + .arginfo = QCOM_SCM_ARGS(1),
> + .args[0] = peripheral,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
>
> ret = qcom_scm_clk_enable();
> if (ret)
> return ret;
>
> - ret = __qcom_scm_pas_shutdown(__scm->dev, peripheral);
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> +
> qcom_scm_clk_disable();
>
> - return ret;
> + return ret ? : res.result[0];
> }
> EXPORT_SYMBOL(qcom_scm_pas_shutdown);
>
> @@ -278,16 +431,44 @@ EXPORT_SYMBOL(qcom_scm_pas_shutdown);
> bool qcom_scm_pas_supported(u32 peripheral)
> {
> int ret;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_PIL,
> + .cmd = QCOM_SCM_PIL_PAS_IS_SUPPORTED,
> + .arginfo = QCOM_SCM_ARGS(1),
> + .args[0] = peripheral,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
>
> ret = __qcom_scm_is_call_available(__scm->dev, QCOM_SCM_SVC_PIL,
> QCOM_SCM_PIL_PAS_IS_SUPPORTED);
> if (ret <= 0)
> return false;
>
> - return __qcom_scm_pas_supported(__scm->dev, peripheral);
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> +
> + return ret ? false : !!res.result[0];
> }
> EXPORT_SYMBOL(qcom_scm_pas_supported);
>
> +static int __qcom_scm_pas_mss_reset(struct device *dev, bool reset)
> +{
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_PIL,
> + .cmd = QCOM_SCM_PIL_PAS_MSS_RESET,
> + .arginfo = QCOM_SCM_ARGS(2),
> + .args[0] = reset,
> + .args[1] = 0,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
> + int ret;
> +
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> +
> + return ret ? : res.result[0];
> +}
> +
> static int qcom_scm_pas_reset_assert(struct reset_controller_dev *rcdev,
> unsigned long idx)
> {
> @@ -313,13 +494,38 @@ static const struct reset_control_ops qcom_scm_pas_reset_ops = {
>
> int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val)
> {
> - return __qcom_scm_io_readl(__scm->dev, addr, val);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_IO,
> + .cmd = QCOM_SCM_IO_READ,
> + .arginfo = QCOM_SCM_ARGS(1),
> + .args[0] = addr,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
> + int ret;
> +
> +
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> + if (ret >= 0)
> + *val = res.result[0];
> +
> + return ret < 0 ? ret : 0;
> }
> EXPORT_SYMBOL(qcom_scm_io_readl);
>
> int qcom_scm_io_writel(phys_addr_t addr, unsigned int val)
> {
> - return __qcom_scm_io_writel(__scm->dev, addr, val);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_IO,
> + .cmd = QCOM_SCM_IO_WRITE,
> + .arginfo = QCOM_SCM_ARGS(2),
> + .args[0] = addr,
> + .args[1] = val,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> +
> +
> + return qcom_scm_call(__scm->dev, &desc, NULL);
> }
> EXPORT_SYMBOL(qcom_scm_io_writel);
>
> @@ -338,22 +544,101 @@ EXPORT_SYMBOL(qcom_scm_restore_sec_cfg_available);
>
> int qcom_scm_restore_sec_cfg(u32 device_id, u32 spare)
> {
> - return __qcom_scm_restore_sec_cfg(__scm->dev, device_id, spare);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_MP,
> + .cmd = QCOM_SCM_MP_RESTORE_SEC_CFG,
> + .arginfo = QCOM_SCM_ARGS(2),
> + .args[0] = device_id,
> + .args[1] = spare,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
> + int ret;
> +
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> +
> + return ret ? : res.result[0];
> }
> EXPORT_SYMBOL(qcom_scm_restore_sec_cfg);
>
> int qcom_scm_iommu_secure_ptbl_size(u32 spare, size_t *size)
> {
> - return __qcom_scm_iommu_secure_ptbl_size(__scm->dev, spare, size);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_MP,
> + .cmd = QCOM_SCM_MP_IOMMU_SECURE_PTBL_SIZE,
> + .arginfo = QCOM_SCM_ARGS(1),
> + .args[0] = spare,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
> + int ret;
> +
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> +
> + if (size)
> + *size = res.result[0];
> +
> + return ret ? : res.result[1];
> }
> EXPORT_SYMBOL(qcom_scm_iommu_secure_ptbl_size);
>
> int qcom_scm_iommu_secure_ptbl_init(u64 addr, u32 size, u32 spare)
> {
> - return __qcom_scm_iommu_secure_ptbl_init(__scm->dev, addr, size, spare);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_MP,
> + .cmd = QCOM_SCM_MP_IOMMU_SECURE_PTBL_INIT,
> + .arginfo = QCOM_SCM_ARGS(3, QCOM_SCM_RW, QCOM_SCM_VAL,
> + QCOM_SCM_VAL),
> + .args[0] = addr,
> + .args[1] = size,
> + .args[2] = spare,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + int ret;
> +
> + desc.args[0] = addr;
> + desc.args[1] = size;
> + desc.args[2] = spare;
> + desc.arginfo = QCOM_SCM_ARGS(3, QCOM_SCM_RW, QCOM_SCM_VAL,
> + QCOM_SCM_VAL);
> +
> + ret = qcom_scm_call(__scm->dev, &desc, NULL);
> +
> + /* the pg table has been initialized already, ignore the error */
> + if (ret == -EPERM)
> + ret = 0;
> +
> + return ret;
> }
> EXPORT_SYMBOL(qcom_scm_iommu_secure_ptbl_init);
>
> +static int __qcom_scm_assign_mem(struct device *dev, phys_addr_t mem_region,
> + size_t mem_sz, phys_addr_t src, size_t src_sz,
> + phys_addr_t dest, size_t dest_sz)
> +{
> + int ret;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_MP,
> + .cmd = QCOM_SCM_MP_ASSIGN,
> + .arginfo = QCOM_SCM_ARGS(7, QCOM_SCM_RO, QCOM_SCM_VAL,
> + QCOM_SCM_RO, QCOM_SCM_VAL, QCOM_SCM_RO,
> + QCOM_SCM_VAL, QCOM_SCM_VAL),
> + .args[0] = mem_region,
> + .args[1] = mem_sz,
> + .args[2] = src,
> + .args[3] = src_sz,
> + .args[4] = dest,
> + .args[5] = dest_sz,
> + .args[6] = 0,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
> +
> + ret = qcom_scm_call(dev, &desc, &res);
> +
> + return ret ? : res.result[0];
> +}
> +
> /**
> * qcom_scm_assign_mem() - Make a secure call to reassign memory ownership
> * @mem_addr: mem region whose ownership need to be reassigned
> @@ -458,7 +743,17 @@ EXPORT_SYMBOL(qcom_scm_ocmem_lock_available);
> int qcom_scm_ocmem_lock(enum qcom_scm_ocmem_client id, u32 offset, u32 size,
> u32 mode)
> {
> - return __qcom_scm_ocmem_lock(__scm->dev, id, offset, size, mode);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_OCMEM,
> + .cmd = QCOM_SCM_OCMEM_LOCK_CMD,
> + .args[0] = id,
> + .args[1] = offset,
> + .args[2] = size,
> + .args[3] = mode,
> + .arginfo = QCOM_SCM_ARGS(4),
> + };
> +
> + return qcom_scm_call(__scm->dev, &desc, NULL);
> }
> EXPORT_SYMBOL(qcom_scm_ocmem_lock);
>
> @@ -472,7 +767,16 @@ EXPORT_SYMBOL(qcom_scm_ocmem_lock);
> */
> int qcom_scm_ocmem_unlock(enum qcom_scm_ocmem_client id, u32 offset, u32 size)
> {
> - return __qcom_scm_ocmem_unlock(__scm->dev, id, offset, size);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_OCMEM,
> + .cmd = QCOM_SCM_OCMEM_UNLOCK_CMD,
> + .args[0] = id,
> + .args[1] = offset,
> + .args[2] = size,
> + .arginfo = QCOM_SCM_ARGS(3),
> + };
> +
> + return qcom_scm_call(__scm->dev, &desc, NULL);
> }
> EXPORT_SYMBOL(qcom_scm_ocmem_unlock);
>
> @@ -507,20 +811,56 @@ EXPORT_SYMBOL(qcom_scm_hdcp_available);
> */
> int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt, u32 *resp)
> {
> - int ret = qcom_scm_clk_enable();
> + int ret;
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_HDCP,
> + .cmd = QCOM_SCM_HDCP_INVOKE,
> + .arginfo = QCOM_SCM_ARGS(10),
> + .args = {
> + req[0].addr,
> + req[0].val,
> + req[1].addr,
> + req[1].val,
> + req[2].addr,
> + req[2].val,
> + req[3].addr,
> + req[3].val,
> + req[4].addr,
> + req[4].val
> + },
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> + struct qcom_scm_res res;
> +
> + if (req_cnt > QCOM_SCM_HDCP_MAX_REQ_CNT)
> + return -ERANGE;
>
> + ret = qcom_scm_clk_enable();
> if (ret)
> return ret;
>
> - ret = __qcom_scm_hdcp_req(__scm->dev, req, req_cnt, resp);
> + ret = qcom_scm_call(__scm->dev, &desc, &res);
> + *resp = res.result[0];
> +
> qcom_scm_clk_disable();
> +
> return ret;
> }
> EXPORT_SYMBOL(qcom_scm_hdcp_req);
>
> int qcom_scm_qsmmu500_wait_safe_toggle(bool en)
> {
> - return __qcom_scm_qsmmu500_wait_safe_toggle(__scm->dev, en);
> + struct qcom_scm_desc desc = {
> + .svc = QCOM_SCM_SVC_SMMU_PROGRAM,
> + .cmd = QCOM_SCM_SMMU_CONFIG_ERRATA1,
> + .arginfo = QCOM_SCM_ARGS(2),
> + .args[0] = QCOM_SCM_SMMU_CONFIG_ERRATA1_CLIENT_ALL,
> + .args[1] = en,
> + .owner = ARM_SMCCC_OWNER_SIP,
> + };
> +
> +
> + return qcom_scm_call_atomic(__scm->dev, &desc, NULL);
> }
> EXPORT_SYMBOL(qcom_scm_qsmmu500_wait_safe_toggle);
>
> diff --git a/drivers/firmware/qcom_scm.h b/drivers/firmware/qcom_scm.h
> index 56ace3b..9b7b357 100644
> --- a/drivers/firmware/qcom_scm.h
> +++ b/drivers/firmware/qcom_scm.h
> @@ -3,19 +3,64 @@
> */
> #ifndef __QCOM_SCM_INT_H
> #define __QCOM_SCM_INT_H
> +#define MAX_QCOM_SCM_ARGS 10
> +#define MAX_QCOM_SCM_RETS 3
> +
> +enum qcom_scm_arg_types {
> + QCOM_SCM_VAL,
> + QCOM_SCM_RO,
> + QCOM_SCM_RW,
> + QCOM_SCM_BUFVAL,
> +};
> +
> +#define QCOM_SCM_ARGS_IMPL(num, a, b, c, d, e, f, g, h, i, j, ...) (\
> + (((a) & 0x3) << 4) | \
> + (((b) & 0x3) << 6) | \
> + (((c) & 0x3) << 8) | \
> + (((d) & 0x3) << 10) | \
> + (((e) & 0x3) << 12) | \
> + (((f) & 0x3) << 14) | \
> + (((g) & 0x3) << 16) | \
> + (((h) & 0x3) << 18) | \
> + (((i) & 0x3) << 20) | \
> + (((j) & 0x3) << 22) | \
> + ((num) & 0xf))
> +
> +#define QCOM_SCM_ARGS(...) QCOM_SCM_ARGS_IMPL(__VA_ARGS__, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
> +
> +
> +/**
> + * struct qcom_scm_desc
> + * @arginfo: Metadata describing the arguments in args[]
> + * @args: The array of arguments for the secure syscall
> + */
> +struct qcom_scm_desc {
> + u32 svc;
> + u32 cmd;
> + u32 arginfo;
> + u64 args[MAX_QCOM_SCM_ARGS];
> + u32 owner;
> +};
> +
> +/**
> + * struct qcom_scm_res
> + * @result: The values returned by the secure syscall
> + */
> +struct qcom_scm_res {
> + u64 result[MAX_QCOM_SCM_RETS];
> +};
> +
> +extern int qcom_scm_call(struct device *dev, const struct qcom_scm_desc *desc,
> + struct qcom_scm_res *res);
> +extern int qcom_scm_call_atomic(struct device *dev,
> + const struct qcom_scm_desc *desc,
> + struct qcom_scm_res *res);
>
> #define QCOM_SCM_SVC_BOOT 0x01
> #define QCOM_SCM_BOOT_SET_ADDR 0x01
> #define QCOM_SCM_BOOT_TERMINATE_PC 0x02
> #define QCOM_SCM_BOOT_SET_DLOAD_MODE 0x10
> #define QCOM_SCM_BOOT_SET_REMOTE_STATE 0x0a
> -extern int __qcom_scm_set_warm_boot_addr(struct device *dev, void *entry,
> - const cpumask_t *cpus);
> -extern int __qcom_scm_set_cold_boot_addr(struct device *dev, void *entry,
> - const cpumask_t *cpus);
> -extern void __qcom_scm_cpu_power_down(struct device *dev, u32 flags);
> -extern int __qcom_scm_set_remote_state(struct device *dev, u32 state, u32 id);
> -extern int __qcom_scm_set_dload_mode(struct device *dev, bool enable);
> #define QCOM_SCM_FLUSH_FLAG_MASK 0x3
>
> #define QCOM_SCM_SVC_PIL 0x02
> @@ -25,20 +70,10 @@ extern int __qcom_scm_set_dload_mode(struct device *dev, bool enable);
> #define QCOM_SCM_PIL_PAS_SHUTDOWN 0x06
> #define QCOM_SCM_PIL_PAS_IS_SUPPORTED 0x07
> #define QCOM_SCM_PIL_PAS_MSS_RESET 0x0a
> -extern bool __qcom_scm_pas_supported(struct device *dev, u32 peripheral);
> -extern int __qcom_scm_pas_init_image(struct device *dev, u32 peripheral,
> - dma_addr_t metadata_phys);
> -extern int __qcom_scm_pas_mem_setup(struct device *dev, u32 peripheral,
> - phys_addr_t addr, phys_addr_t size);
> -extern int __qcom_scm_pas_auth_and_reset(struct device *dev, u32 peripheral);
> -extern int __qcom_scm_pas_shutdown(struct device *dev, u32 peripheral);
> -extern int __qcom_scm_pas_mss_reset(struct device *dev, bool reset);
>
> #define QCOM_SCM_SVC_IO 0x05
> #define QCOM_SCM_IO_READ 0x01
> #define QCOM_SCM_IO_WRITE 0x02
> -extern int __qcom_scm_io_readl(struct device *dev, phys_addr_t addr, unsigned int *val);
> -extern int __qcom_scm_io_writel(struct device *dev, phys_addr_t addr, unsigned int val);
>
> #define QCOM_SCM_SVC_INFO 0x06
> #define QCOM_SCM_INFO_IS_CALL_AVAIL 0x01
> @@ -50,35 +85,17 @@ extern int __qcom_scm_is_call_available(struct device *dev, u32 svc_id,
> #define QCOM_SCM_MP_IOMMU_SECURE_PTBL_SIZE 0x03
> #define QCOM_SCM_MP_IOMMU_SECURE_PTBL_INIT 0x04
> #define QCOM_SCM_MP_ASSIGN 0x16
> -extern int __qcom_scm_restore_sec_cfg(struct device *dev, u32 device_id,
> - u32 spare);
> -extern int __qcom_scm_iommu_secure_ptbl_size(struct device *dev, u32 spare,
> - size_t *size);
> -extern int __qcom_scm_iommu_secure_ptbl_init(struct device *dev, u64 addr,
> - u32 size, u32 spare);
> -extern int __qcom_scm_assign_mem(struct device *dev,
> - phys_addr_t mem_region, size_t mem_sz,
> - phys_addr_t src, size_t src_sz,
> - phys_addr_t dest, size_t dest_sz);
>
> #define QCOM_SCM_SVC_OCMEM 0x0f
> #define QCOM_SCM_OCMEM_LOCK_CMD 0x01
> #define QCOM_SCM_OCMEM_UNLOCK_CMD 0x02
> -extern int __qcom_scm_ocmem_lock(struct device *dev, u32 id, u32 offset,
> - u32 size, u32 mode);
> -extern int __qcom_scm_ocmem_unlock(struct device *dev, u32 id, u32 offset,
> - u32 size);
>
> #define QCOM_SCM_SVC_HDCP 0x11
> #define QCOM_SCM_HDCP_INVOKE 0x01
> -extern int __qcom_scm_hdcp_req(struct device *dev,
> - struct qcom_scm_hdcp_req *req, u32 req_cnt, u32 *resp);
>
> #define QCOM_SCM_SVC_SMMU_PROGRAM 0x15
> #define QCOM_SCM_SMMU_CONFIG_ERRATA1 0x03
> #define QCOM_SCM_SMMU_CONFIG_ERRATA1_CLIENT_ALL 0x02
> -extern int __qcom_scm_qsmmu500_wait_safe_toggle(struct device *dev,
> - bool enable);
>
> extern void __qcom_scm_init(void);
>
> --
> The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum,
> a Linux Foundation Collaborative Project
>

\
 
 \ /
  Last update: 2020-01-05 12:23    [W:0.082 / U:6.112 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site