remoteproc: pas: Extend parse_fw callback to fetch resources via SMC call

Qualcomm remote processor may rely on static and dynamic resources for
it to be functional. For most of the Qualcomm SoCs, when run with Gunyah
or older QHEE hypervisor, all the resources whether it is static or
dynamic, is managed by the hypervisor. Dynamic resources if it is
present for a remote processor will always be coming from secure world
via SMC call while static resources may be present in remote processor
firmware binary or it may be coming from SMC call along with dynamic
resources.

Remoteproc already has method like rproc_elf_load_rsc_table() to check
firmware binary has resources or not and if it is not having then we
pass NULL and zero as input resource table and its size argument
respectively to qcom_scm_pas_get_rsc_table() and while it has resource
present then it should pass the present resources to Trustzone(TZ) so that
it could authenticate the present resources and append dynamic resource
to return in output_rt argument along with authenticated resources.

Extend parse_fw callback to include SMC call to get resources from
Trustzone and to leverage resource table parsing and mapping and
unmapping code from the remoteproc framework.

Reviewed-by: Konrad Dybcio <konrad.dybcio@oss.qualcomm.com>
Signed-off-by: Mukesh Ojha <mukesh.ojha@oss.qualcomm.com>
Link: https://lore.kernel.org/r/20260105-kvmrprocv10-v10-12-022e96815380@oss.qualcomm.com
Signed-off-by: Bjorn Andersson <andersson@kernel.org>

diff --git a/drivers/remoteproc/qcom_q6v5_pas.c b/drivers/remoteproc/qcom_q6v5_pas.c
index f746d2f39a1d89cef2f1470eb548c9903cf3d66a..e0c7bf94bfc673d76883ab824233951246a6bc11 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_pas.c
+++ b/drivers/remoteproc/qcom_q6v5_pas.c
@@ -413,6 +413,61 @@ static void *qcom_pas_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is
        return pas->mem_region + offset;
 }
 
+static int qcom_pas_parse_firmware(struct rproc *rproc, const struct firmware *fw)
+{
+       struct qcom_pas *pas = rproc->priv;
+       struct resource_table *table = NULL;
+       size_t output_rt_size;
+       void *output_rt;
+       size_t table_sz;
+       int ret;
+
+       ret = qcom_register_dump_segments(rproc, fw);
+       if (ret) {
+               dev_err(pas->dev, "Error in registering dump segments\n");
+               return ret;
+       }
+
+       if (!rproc->has_iommu)
+               return 0;
+
+       ret = rproc_elf_load_rsc_table(rproc, fw);
+       if (ret)
+               dev_dbg(&rproc->dev, "Failed to load resource table from firmware\n");
+
+       table = rproc->table_ptr;
+       table_sz = rproc->table_sz;
+
+       /*
+        * The resources consumed by Qualcomm remote processors fall into two categories:
+        * static (such as the memory carveouts for the rproc firmware) and dynamic (like
+        * shared memory pools). Both are managed by a Qualcomm hypervisor (such as QHEE
+        * or Gunyah), if one is present. Otherwise, a resource table must be retrieved
+        * via an SCM call. That table will list all dynamic resources (if any) and possibly
+        * the static ones. The static resources may also come from a resource table embedded
+        * in the rproc firmware instead.
+        *
+        * Here, we call rproc_elf_load_rsc_table() to check firmware binary has resources
+        * or not and if it is not having then we pass NULL and zero as input resource
+        * table pointer and size respectively to the argument of qcom_scm_pas_get_rsc_table()
+        * and this is even true for Qualcomm remote processor who does follow remoteproc
+        * framework.
+        */
+       output_rt = qcom_scm_pas_get_rsc_table(pas->pas_ctx, table, table_sz, &output_rt_size);
+       ret = IS_ERR(output_rt) ? PTR_ERR(output_rt) : 0;
+       if (ret) {
+               dev_err(pas->dev, "Error in getting resource table: %d\n", ret);
+               return ret;
+       }
+
+       kfree(rproc->cached_table);
+       rproc->cached_table = output_rt;
+       rproc->table_ptr = rproc->cached_table;
+       rproc->table_sz = output_rt_size;
+
+       return ret;
+}
+
 static unsigned long qcom_pas_panic(struct rproc *rproc)
 {
        struct qcom_pas *pas = rproc->priv;
@@ -425,7 +480,7 @@ static const struct rproc_ops qcom_pas_ops = {
        .start = qcom_pas_start,
        .stop = qcom_pas_stop,
        .da_to_va = qcom_pas_da_to_va,
-       .parse_fw = qcom_register_dump_segments,
+       .parse_fw = qcom_pas_parse_firmware,
        .load = qcom_pas_load,
        .panic = qcom_pas_panic,
 };
@@ -435,7 +490,7 @@ static const struct rproc_ops qcom_pas_minidump_ops = {
        .start = qcom_pas_start,
        .stop = qcom_pas_stop,
        .da_to_va = qcom_pas_da_to_va,
-       .parse_fw = qcom_register_dump_segments,
+       .parse_fw = qcom_pas_parse_firmware,
        .load = qcom_pas_load,
        .panic = qcom_pas_panic,
        .coredump = qcom_pas_minidump,