Dropping the common.h header resulted in the spin table header missing asm/types.h and the source unit missing the errno.h includes.

Fixes: 7410cde67de ("arm: Remove <common.h> and add needed includes") Signed-off-by: Sam Day me@samcday.com --- arch/arm/cpu/armv8/spin_table.c | 1 + arch/arm/include/asm/spin_table.h | 2 ++ 2 files changed, 3 insertions(+)

diff --git a/arch/arm/cpu/armv8/spin_table.c b/arch/arm/cpu/armv8/spin_table.c index 485294b88d0ac5516f58fb616ca59eebe30ef022..13b300f5c67a6dd257b2cb53350a7b5bafa3db96 100644 --- a/arch/arm/cpu/armv8/spin_table.c +++ b/arch/arm/cpu/armv8/spin_table.c @@ -6,6 +6,7 @@

#include <linux/libfdt.h> #include <asm/spin_table.h> +#include <errno.h>

int spin_table_update_dt(void *fdt) { diff --git a/arch/arm/include/asm/spin_table.h b/arch/arm/include/asm/spin_table.h index dec18c6e5c1ba15c8f96ccae8e9bb5415c845a5b..8fc61237e07559f267e1da1fbc8ee646ef08721f 100644 --- a/arch/arm/include/asm/spin_table.h +++ b/arch/arm/include/asm/spin_table.h @@ -3,6 +3,8 @@ #ifndef __ASM_SPIN_TABLE_H__ #define __ASM_SPIN_TABLE_H__

+#include <asm/types.h> + extern u64 spin_table_cpu_release_addr; extern char spin_table_reserve_begin; extern char spin_table_reserve_end;

Introduce the weak symbol spin_table_boot_cpu, which is called by spin_table_update_dt during pre-boot FDT fixup phase for each CPU that has enable-method="spin-table".

This saves the board/arch code from needing to scan the DT looking for CPUs to boot, and also makes it easier to bring the secondary CPUs online as late as possible.

Signed-off-by: Sam Day me@samcday.com --- arch/arm/cpu/armv8/spin_table.c | 9 +++++++++ arch/arm/include/asm/spin_table.h | 1 + 2 files changed, 10 insertions(+)

diff --git a/arch/arm/cpu/armv8/spin_table.c b/arch/arm/cpu/armv8/spin_table.c index 13b300f5c67a6dd257b2cb53350a7b5bafa3db96..f83ff456f26d41402b83f0e30a65f8fc48e42fbe 100644 --- a/arch/arm/cpu/armv8/spin_table.c +++ b/arch/arm/cpu/armv8/spin_table.c @@ -8,6 +8,11 @@ #include <asm/spin_table.h> #include <errno.h>

+int __weak spin_table_boot_cpu(void *fdt, int cpu_offset) +{ + return 0; +} + int spin_table_update_dt(void *fdt) { int cpus_offset, offset; @@ -45,6 +50,10 @@ int spin_table_update_dt(void *fdt) if (!prop || strcmp(prop, "cpu")) continue;

+ ret = spin_table_boot_cpu(fdt, offset); + if (ret) + return ret; + ret = fdt_setprop_u64(fdt, offset, "cpu-release-addr", (unsigned long)&spin_table_cpu_release_addr); if (ret) diff --git a/arch/arm/include/asm/spin_table.h b/arch/arm/include/asm/spin_table.h index 8fc61237e07559f267e1da1fbc8ee646ef08721f..3c422046b830a7a81d7de806ff0db92d346446d2 100644 --- a/arch/arm/include/asm/spin_table.h +++ b/arch/arm/include/asm/spin_table.h @@ -10,5 +10,6 @@ extern char spin_table_reserve_begin; extern char spin_table_reserve_end;

int spin_table_update_dt(void *fdt); +int spin_table_boot_cpu(void *fdt, int cpu_offset);

#endif /* __ASM_SPIN_TABLE_H__ */

These calls are a little more complex than a standard SMCCC instruction. There's 32bit/64bit calling conventions, support for passing more arguments than can fit in the usual registers (by placing a pointer to the additional args in x7), and the use of a qcom-specific smccc quirk.

Signed-off-by: Sam Day me@samcday.com --- arch/arm/mach-snapdragon/Makefile | 1 + arch/arm/mach-snapdragon/qcom-scm.c | 145 +++++++++++++++++++++++++++++++ arch/arm/mach-snapdragon/qcom-scm.h | 165 ++++++++++++++++++++++++++++++++++++ 3 files changed, 311 insertions(+)

diff --git a/arch/arm/mach-snapdragon/Makefile b/arch/arm/mach-snapdragon/Makefile index 343e825c6fdd05f36e210b138e741b7b7dd606ac..e3b9510d25da040e72aa61668014f4863add6b5a 100644 --- a/arch/arm/mach-snapdragon/Makefile +++ b/arch/arm/mach-snapdragon/Makefile @@ -3,5 +3,6 @@ # (C) Copyright 2015 Mateusz Kulikowski mateusz.kulikowski@gmail.com

obj-y += board.o +obj-y += qcom-scm.o obj-$(CONFIG_EFI_HAVE_CAPSULE_SUPPORT) += capsule_update.o obj-$(CONFIG_OF_LIVE) += of_fixup.o diff --git a/arch/arm/mach-snapdragon/qcom-scm.c b/arch/arm/mach-snapdragon/qcom-scm.c new file mode 100644 index 0000000000000000000000000000000000000000..b9ccd1bbb7c1a43d864f2d5f3804836a06607b11 --- /dev/null +++ b/arch/arm/mach-snapdragon/qcom-scm.c @@ -0,0 +1,145 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* Copyright (c) 2025 Linaro Ltd. */ + +/* Much of this code was adapted from Linux kernel */ +/* Copyright (c) 2010-2015,2019 The Linux Foundation. All rights reserved. + */ + +#include "qcom-scm.h" + +#define QCOM_SCM_EBUSY_WAIT_MS 30 +#define QCOM_SCM_EBUSY_MAX_RETRY 20 + +#define SCM_SMC_N_REG_ARGS 4 +#define SCM_SMC_FIRST_EXT_IDX (SCM_SMC_N_REG_ARGS - 1) +#define SCM_SMC_N_EXT_ARGS (MAX_QCOM_SCM_ARGS - SCM_SMC_N_REG_ARGS + 1) +#define SCM_SMC_FIRST_REG_IDX 2 +#define SCM_SMC_LAST_REG_IDX (SCM_SMC_FIRST_REG_IDX + SCM_SMC_N_REG_ARGS - 1) + +/** + * struct arm_smccc_args + * @args: The array of values used in registers in smc instruction + */ +struct arm_smccc_args { + unsigned long args[8]; +}; + +static void __scm_smc_do_quirk(const struct arm_smccc_args *smc, + struct arm_smccc_res *res) +{ + unsigned long a0 = smc->args[0]; + struct arm_smccc_quirk quirk = { .id = ARM_SMCCC_QUIRK_QCOM_A6 }; + + quirk.state.a6 = 0; + + do { + arm_smccc_smc_quirk(a0, smc->args[1], smc->args[2], + smc->args[3], smc->args[4], smc->args[5], + quirk.state.a6, smc->args[7], res, &quirk); + + if (res->a0 == QCOM_SCM_INTERRUPTED) + a0 = res->a0; + + } while (res->a0 == QCOM_SCM_INTERRUPTED); +} + +static int __scm_smc_do(struct arm_smccc_args *smc, struct arm_smccc_res *res, + bool atomic) +{ + int retry_count = 0; + + do { + __scm_smc_do_quirk(smc, res); + + if (atomic) + return 0; + + if (res->a0 == QCOM_SCM_V2_EBUSY) { + if (retry_count++ > QCOM_SCM_EBUSY_MAX_RETRY) + break; + mdelay(QCOM_SCM_EBUSY_WAIT_MS); + } + } while (res->a0 == QCOM_SCM_V2_EBUSY); + + return 0; +} + +int qcom_scm_call(const struct qcom_scm_desc *desc, + enum qcom_scm_convention qcom_convention, + struct qcom_scm_res *res, bool atomic) +{ + int arglen = desc->arginfo & 0xf; + void *args = NULL; + int i, ret; + struct arm_smccc_args smc = {0}; + struct arm_smccc_res smc_res; + u32 smccc_call_type = atomic ? ARM_SMCCC_FAST_CALL : ARM_SMCCC_STD_CALL; + u32 qcom_smccc_convention = (qcom_convention == SMC_CONVENTION_ARM_32) ? + ARM_SMCCC_SMC_32 : ARM_SMCCC_SMC_64; + u32 fnid = SCM_SMC_FNID(desc->svc, desc->cmd); + + smc.args[0] = ARM_SMCCC_CALL_VAL(smccc_call_type, qcom_smccc_convention, + desc->owner, fnid); + smc.args[1] = desc->arginfo; + for (i = 0; i < SCM_SMC_N_REG_ARGS; i++) + smc.args[i + SCM_SMC_FIRST_REG_IDX] = desc->args[i]; + + if (unlikely(arglen > SCM_SMC_N_REG_ARGS)) { + args = malloc_cache_aligned(SCM_SMC_N_EXT_ARGS * sizeof(u64)); + if (!args) + return -ENOMEM; + + if (qcom_smccc_convention == ARM_SMCCC_SMC_32) { + __le32 *args32 = args; + + for (i = 0; i < SCM_SMC_N_EXT_ARGS; i++) + args32[i] = cpu_to_le32(desc->args[i + + SCM_SMC_FIRST_EXT_IDX]); + } else { + __le64 *args64 = args; + + for (i = 0; i < SCM_SMC_N_EXT_ARGS; i++) + args64[i] = cpu_to_le64(desc->args[i + + SCM_SMC_FIRST_EXT_IDX]); + } + + smc.args[SCM_SMC_LAST_REG_IDX] = (phys_addr_t)args; + flush_cache((unsigned long)args, SCM_SMC_N_EXT_ARGS * sizeof(u64)); + } + + ret = __scm_smc_do(&smc, &smc_res, atomic); + + if (args) + free(args); + + if (ret) + return ret; + + if (res) { + res->result[0] = smc_res.a1; + res->result[1] = smc_res.a2; + res->result[2] = smc_res.a3; + } + + return (long)smc_res.a0 ? qcom_scm_remap_error(smc_res.a0) : 0; +} + +bool qcom_scm_is_call_available(u32 svc_id, u32 cmd_id, + enum qcom_scm_convention convention) +{ + u32 fnid = SCM_SMC_FNID(svc_id, cmd_id); + struct qcom_scm_res scm_ret = {0}; + struct qcom_scm_desc desc = { + .svc = QCOM_SCM_SVC_INFO, + .cmd = QCOM_SCM_INFO_IS_CALL_AVAIL, + .owner = ARM_SMCCC_OWNER_SIP, + .arginfo = QCOM_SCM_ARGS(1), + .args = { + ARM_SMCCC_CALL_VAL(ARM_SMCCC_STD_CALL, convention, + ARM_SMCCC_OWNER_SIP, fnid) + }, + }; + if (qcom_scm_call(&desc, convention, &scm_ret, false)) + return false; + return scm_ret.result[0]; +} diff --git a/arch/arm/mach-snapdragon/qcom-scm.h b/arch/arm/mach-snapdragon/qcom-scm.h new file mode 100644 index 0000000000000000000000000000000000000000..053d8b3c8cd44566f62b129e228963a50c678e19 --- /dev/null +++ b/arch/arm/mach-snapdragon/qcom-scm.h @@ -0,0 +1,165 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* This header was adapted from linux/drivers/firmware/qcom/qcom_scm.h */ +/* Copyright (c) 2010-2015,2019 The Linux Foundation. All rights reserved. + */ +#ifndef __QCOM_SCM_INT_H +#define __QCOM_SCM_INT_H + +#include <asm/io.h> +#include <errno.h> +#include <linux/arm-smccc.h> +#include <linux/delay.h> +#include <linux/types.h> +#include <memalign.h> + +enum qcom_scm_convention { + SMC_CONVENTION_UNKNOWN, + SMC_CONVENTION_LEGACY, + SMC_CONVENTION_ARM_32, + SMC_CONVENTION_ARM_64, +}; + +extern enum qcom_scm_convention qcom_scm_convention; + +#define MAX_QCOM_SCM_ARGS 10 +#define MAX_QCOM_SCM_RETS 3 + +#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]; +}; + +#define SCM_SMC_FNID(s, c) ((((s) & 0xFF) << 8) | ((c) & 0xFF)) + +#define QCOM_SCM_SVC_BOOT 0x01 +#define QCOM_SCM_BOOT_SET_ADDR 0x01 +#define QCOM_SCM_BOOT_TERMINATE_PC 0x02 +#define QCOM_SCM_BOOT_SDI_CONFIG 0x09 +#define QCOM_SCM_BOOT_SET_DLOAD_MODE 0x10 +#define QCOM_SCM_BOOT_SET_ADDR_MC 0x11 +#define QCOM_SCM_BOOT_SET_REMOTE_STATE 0x0a +#define QCOM_SCM_FLUSH_FLAG_MASK 0x3 +#define QCOM_SCM_BOOT_MAX_CPUS 4 +#define QCOM_SCM_BOOT_MC_FLAG_AARCH64 BIT(0) +#define QCOM_SCM_BOOT_MC_FLAG_COLDBOOT BIT(1) +#define QCOM_SCM_BOOT_MC_FLAG_WARMBOOT BIT(2) + +#define QCOM_SCM_SVC_PIL 0x02 +#define QCOM_SCM_PIL_PAS_INIT_IMAGE 0x01 +#define QCOM_SCM_PIL_PAS_MEM_SETUP 0x02 +#define QCOM_SCM_PIL_PAS_AUTH_AND_RESET 0x05 +#define QCOM_SCM_PIL_PAS_SHUTDOWN 0x06 +#define QCOM_SCM_PIL_PAS_IS_SUPPORTED 0x07 +#define QCOM_SCM_PIL_PAS_MSS_RESET 0x0a + +#define QCOM_SCM_SVC_IO 0x05 +#define QCOM_SCM_IO_READ 0x01 +#define QCOM_SCM_IO_WRITE 0x02 + +#define QCOM_SCM_SVC_INFO 0x06 +#define QCOM_SCM_INFO_IS_CALL_AVAIL 0x01 + +#define QCOM_SCM_SVC_MP 0x0c +#define QCOM_SCM_MP_RESTORE_SEC_CFG 0x02 +#define QCOM_SCM_MP_IOMMU_SECURE_PTBL_SIZE 0x03 +#define QCOM_SCM_MP_IOMMU_SECURE_PTBL_INIT 0x04 +#define QCOM_SCM_MP_IOMMU_SET_CP_POOL_SIZE 0x05 +#define QCOM_SCM_MP_VIDEO_VAR 0x08 +#define QCOM_SCM_MP_ASSIGN 0x16 +#define QCOM_SCM_MP_SHM_BRIDGE_ENABLE 0x1c +#define QCOM_SCM_MP_SHM_BRIDGE_DELETE 0x1d +#define QCOM_SCM_MP_SHM_BRIDGE_CREATE 0x1e + +#define QCOM_SCM_SVC_OCMEM 0x0f +#define QCOM_SCM_OCMEM_LOCK_CMD 0x01 +#define QCOM_SCM_OCMEM_UNLOCK_CMD 0x02 + +#define QCOM_SCM_SVC_ES 0x10 /* Enterprise Security */ +#define QCOM_SCM_ES_INVALIDATE_ICE_KEY 0x03 +#define QCOM_SCM_ES_CONFIG_SET_ICE_KEY 0x04 + +#define QCOM_SCM_SVC_HDCP 0x11 +#define QCOM_SCM_HDCP_INVOKE 0x01 + +#define QCOM_SCM_SVC_LMH 0x13 +#define QCOM_SCM_LMH_LIMIT_PROFILE_CHANGE 0x01 +#define QCOM_SCM_LMH_LIMIT_DCVSH 0x10 + +#define QCOM_SCM_SVC_SMMU_PROGRAM 0x15 +#define QCOM_SCM_SMMU_PT_FORMAT 0x01 +#define QCOM_SCM_SMMU_CONFIG_ERRATA1 0x03 +#define QCOM_SCM_SMMU_CONFIG_ERRATA1_CLIENT_ALL 0x02 + +#define QCOM_SCM_SVC_WAITQ 0x24 +#define QCOM_SCM_WAITQ_RESUME 0x02 +#define QCOM_SCM_WAITQ_GET_WQ_CTX 0x03 + +#define QCOM_SCM_SVC_GPU 0x28 +#define QCOM_SCM_SVC_GPU_INIT_REGS 0x01 + +/* common error codes */ +#define QCOM_SCM_V2_EBUSY -12 +#define QCOM_SCM_ENOMEM -5 +#define QCOM_SCM_EOPNOTSUPP -4 +#define QCOM_SCM_EINVAL_ADDR -3 +#define QCOM_SCM_EINVAL_ARG -2 +#define QCOM_SCM_ERROR -1 +#define QCOM_SCM_INTERRUPTED 1 + +static inline int qcom_scm_remap_error(int err) +{ + switch (err) { + case QCOM_SCM_ERROR: + return -EIO; + case QCOM_SCM_EINVAL_ADDR: + case QCOM_SCM_EINVAL_ARG: + return -EINVAL; + case QCOM_SCM_EOPNOTSUPP: + return -EOPNOTSUPP; + case QCOM_SCM_ENOMEM: + return -ENOMEM; + case QCOM_SCM_V2_EBUSY: + return -EBUSY; + } + return -EINVAL; +} + +bool qcom_scm_is_call_available(u32 svc_id, u32 cmd_id, + enum qcom_scm_convention convention); + +int qcom_scm_call(const struct qcom_scm_desc *desc, + enum qcom_scm_convention qcom_convention, + struct qcom_scm_res *res, bool atomic); + +#endif

Most MSM8916 devices lack PSCI support, instead they're brought online with a qcom SCM call to set the boot address, and some register poking of the APCS register block.

Signed-off-by: Sam Day me@samcday.com --- arch/arm/mach-snapdragon/Makefile | 1 + arch/arm/mach-snapdragon/msm8916-smp.c | 135 +++++++++++++++++++++++++++++++++ 2 files changed, 136 insertions(+)

diff --git a/arch/arm/mach-snapdragon/Makefile b/arch/arm/mach-snapdragon/Makefile index e3b9510d25da040e72aa61668014f4863add6b5a..b5122946229afb57d14e20360de12650a5343df7 100644 --- a/arch/arm/mach-snapdragon/Makefile +++ b/arch/arm/mach-snapdragon/Makefile @@ -6,3 +6,4 @@ obj-y += board.o obj-y += qcom-scm.o obj-$(CONFIG_EFI_HAVE_CAPSULE_SUPPORT) += capsule_update.o obj-$(CONFIG_OF_LIVE) += of_fixup.o +obj-$(CONFIG_ARMV8_SPIN_TABLE) += msm8916-smp.o diff --git a/arch/arm/mach-snapdragon/msm8916-smp.c b/arch/arm/mach-snapdragon/msm8916-smp.c new file mode 100644 index 0000000000000000000000000000000000000000..fb044a4df9203783ecaa195a027f037e6e28f6ed --- /dev/null +++ b/arch/arm/mach-snapdragon/msm8916-smp.c @@ -0,0 +1,135 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * On MSM8916 devices that lack a PSCI implementation, firing up the secondary + * cores requires a call to TZ to set the boot address, and some poking of ACPS + * register block. + * + * Copyright (c) 2025 Linaro Ltd. + */ + +#include <asm/spin_table.h> +#include <cpu_func.h> +#include <dm/ofnode.h> +#include "qcom-scm.h" + +#define APCS_CPU_PWR_CTL 0x04 +#define CORE_PWRD_UP BIT(7) +#define COREPOR_RST BIT(5) +#define CORE_RST BIT(4) +#define CORE_MEM_HS BIT(3) +#define CORE_MEM_CLAMP BIT(1) +#define CLAMP BIT(0) + +#define APC_PWR_GATE_CTL 0x14 +#define GDHS_CNT_SHIFT 24 +#define GDHS_EN BIT(0) + +static void qcom_boot_cortex_a53(phys_addr_t acc_base) +{ + u32 reg_val; + + /* Put the CPU into reset. */ + reg_val = CORE_RST | COREPOR_RST | CLAMP | CORE_MEM_CLAMP; + writel(reg_val, acc_base + APCS_CPU_PWR_CTL); + + /* Turn on the GDHS and set the GDHS_CNT to 16 XO clock cycles */ + writel(GDHS_EN | (0x10 << GDHS_CNT_SHIFT), acc_base + APC_PWR_GATE_CTL); + /* Wait for the GDHS to settle */ + udelay(2); + + reg_val &= ~CORE_MEM_CLAMP; + writel(reg_val, acc_base + APCS_CPU_PWR_CTL); + reg_val |= CORE_MEM_HS; + writel(reg_val, acc_base + APCS_CPU_PWR_CTL); + udelay(2); + + reg_val &= ~CLAMP; + writel(reg_val, acc_base + APCS_CPU_PWR_CTL); + udelay(2); + + /* Release CPU out of reset and bring it to life. */ + reg_val &= ~(CORE_RST | COREPOR_RST); + writel(reg_val, acc_base + APCS_CPU_PWR_CTL); + reg_val |= CORE_PWRD_UP; + writel(reg_val, acc_base + APCS_CPU_PWR_CTL); +} + +int qcom_scm_set_boot_addr_mc(void *entry, unsigned int flags) +{ + struct qcom_scm_desc desc = { + .svc = QCOM_SCM_SVC_BOOT, + .cmd = QCOM_SCM_BOOT_SET_ADDR_MC, + .owner = ARM_SMCCC_OWNER_SIP, + .arginfo = QCOM_SCM_ARGS(6), + .args = { + (u64)entry, + /* Apply to all CPUs in all affinity levels */ + ~0ULL, ~0ULL, ~0ULL, ~0ULL, + flags, + }, + }; + + return qcom_scm_call(&desc, SMC_CONVENTION_ARM_32, NULL, false); +} + +static bool boot_addr_set; + +int spin_table_boot_cpu(void *fdt, int cpu_offset) +{ + struct fdtdec_phandle_args acc; + u32 mpidr_aff, acc_base, reg; + int ret; + + reg = fdtdec_get_uint(fdt, cpu_offset, "reg", 0); + + if (fdt_node_check_compatible(fdt, cpu_offset, "arm,cortex-a53")) { + log_warning("CPU%d is not arm,cortex-a53 compatible\n", reg); + return -EINVAL; + } + + if (!boot_addr_set) { + if (!qcom_scm_is_call_available(QCOM_SCM_SVC_BOOT, + QCOM_SCM_BOOT_SET_ADDR_MC, + SMC_CONVENTION_ARM_32)) { + log_warning("BOOT_SET_ADDR_MC unavailable\n"); + return -EPERM; + } + + debug("Setting CPU boot address to 0x%llx\n", + (phys_addr_t)&spin_table_reserve_begin); + ret = qcom_scm_set_boot_addr_mc(&spin_table_reserve_begin, + QCOM_SCM_BOOT_MC_FLAG_AARCH64 | + QCOM_SCM_BOOT_MC_FLAG_COLDBOOT); + if (ret) { + log_err("Failed to set CPU boot addr: %d\n", ret); + return ret; + } + + boot_addr_set = true; + } + + mpidr_aff = read_mpidr() & 0xffffff; + + if (reg == mpidr_aff) { + debug("Skipping boot of current CPU%d\n", reg); + return 0; + } + + ret = fdtdec_parse_phandle_with_args(fdt, cpu_offset, "qcom,acc", + NULL, 0, 0, &acc); + if (ret) { + log_err("Failed to parse qcom,acc phandle: %d\n", reg); + return ret; + } + + acc_base = fdtdec_get_addr_size_auto_noparent(fdt, acc.node, "reg", 0, + NULL, true); + if (!acc_base) { + log_err("Failed to parse qcom,acc regbase\n"); + return -EINVAL; + } + + log_info("Booting CPU%d @ 0x%x\n", reg, acc_base); + qcom_boot_cortex_a53(acc_base); + return 0; +}