Merge tag 'rproc-v5.1' of git://github.com/andersson/remoteproc
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 14 Mar 2019 16:00:06 +0000 (09:00 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 14 Mar 2019 16:00:06 +0000 (09:00 -0700)
Pull remoteproc updates from Bjorn Andersson:
 "This contains the last patches in Loic's remoteproc resource table
  handling changes, a number of updates to documentation, support for
  invoking the crash handler (for testing purposes), a fix for the
  handling of virtio devices during recovery, performance state votes in
  Qualcomm modem driver, support for specifying board specific firmware
  path for Qualcomm modem driver and improved support for graceful
  shutdown of Qualcomm remoteprocs"

* tag 'rproc-v5.1' of git://github.com/andersson/remoteproc: (33 commits)
  remoteproc: fix for "dma-mapping: remove the DMA_MEMORY_EXCLUSIVE flag"
  remoteproc: fix rproc_check_carveout_da() returned error and comments
  remoteproc: fix trace buffer va initialization
  remoteproc: fix rproc_alloc_carveout() for rproc with iommu domain
  remoteproc: add warning on resource table cast
  remoteproc: fix rproc_alloc_carveout() bad variable cast
  remoteproc: fix rproc_da_to_va in case of unallocated carveout
  remoteproc: correct rproc_mem_entry_init() comments
  remoteproc: fix recovery procedure
  rpmsg: virtio: change header file sort style
  rpmsg: virtio: allocate buffer from parent
  remoteproc: st: add reserved memory support
  remoteproc: create vdev subdevice with specific dma memory pool
  remoteproc: q6v5_adsp: Remove voting for lpass_aon clock
  dt-binding: remoteproc: Remove lpass_aon clock from adsp pil clock list
  remoteproc: q6v5-mss: Active powerdomain for SDM845
  remoteproc: q6v5-mss: Vote for rpmh power domains
  remoteproc: qcom: Add support for parsing fw dt bindings
  remoteproc: qcom_q6v5: don't auto boot remote processor
  remoteproc: qcom: Wait for shutdown-ack/ind on sysmon shutdown
  ...

15 files changed:
Documentation/devicetree/bindings/remoteproc/qcom,adsp-pil.txt
Documentation/devicetree/bindings/remoteproc/qcom,adsp.txt
Documentation/devicetree/bindings/remoteproc/qcom,q6v5.txt
drivers/remoteproc/qcom_q6v5_adsp.c
drivers/remoteproc/qcom_q6v5_mss.c
drivers/remoteproc/qcom_q6v5_pas.c
drivers/remoteproc/qcom_sysmon.c
drivers/remoteproc/qcom_wcnss.c
drivers/remoteproc/remoteproc_core.c
drivers/remoteproc/remoteproc_debugfs.c
drivers/remoteproc/remoteproc_internal.h
drivers/remoteproc/remoteproc_virtio.c
drivers/remoteproc/st_remoteproc.c
drivers/rpmsg/virtio_rpmsg_bus.c
include/linux/remoteproc.h

index a842a782b55764ef1c1caf9e4cbb8fc38b6a727f..66af2c30944f4d6e103958ff92921fc1b7f6a668 100644 (file)
@@ -35,7 +35,7 @@ on the Qualcomm Technology Inc. ADSP Hexagon core.
        Value type: <stringlist>
        Definition: List of clock input name strings sorted in the same
                    order as the clocks property. Definition must have
-                   "xo", "sway_cbcr", "lpass_aon", "lpass_ahbs_aon_cbcr",
+                   "xo", "sway_cbcr", "lpass_ahbs_aon_cbcr",
                    "lpass_ahbm_aon_cbcr", "qdsp6ss_xo", "qdsp6ss_sleep"
                    and "qdsp6ss_core".
 
@@ -100,13 +100,12 @@ ADSP, as it is found on SDM845 boards.
 
                clocks = <&rpmhcc RPMH_CXO_CLK>,
                        <&gcc GCC_LPASS_SWAY_CLK>,
-                       <&lpasscc LPASS_AUDIO_WRAPPER_AON_CLK>,
                        <&lpasscc LPASS_Q6SS_AHBS_AON_CLK>,
                        <&lpasscc LPASS_Q6SS_AHBM_AON_CLK>,
                        <&lpasscc LPASS_QDSP6SS_XO_CLK>,
                        <&lpasscc LPASS_QDSP6SS_SLEEP_CLK>,
                        <&lpasscc LPASS_QDSP6SS_CORE_CLK>;
-               clock-names = "xo", "sway_cbcr", "lpass_aon",
+               clock-names = "xo", "sway_cbcr",
                        "lpass_ahbs_aon_cbcr",
                        "lpass_ahbm_aon_cbcr", "qdsp6ss_xo",
                        "qdsp6ss_sleep", "qdsp6ss_core";
index 9c0cff3a5ed8506dd164b42316ec83d63eac404f..292dfda9770d7fb0eae771e125899c437823d003 100644 (file)
@@ -19,13 +19,30 @@ on the Qualcomm ADSP Hexagon core.
 - interrupts-extended:
        Usage: required
        Value type: <prop-encoded-array>
-       Definition: must list the watchdog, fatal IRQs ready, handover and
-                   stop-ack IRQs
+       Definition: reference to the interrupts that match interrupt-names
 
 - interrupt-names:
        Usage: required
        Value type: <stringlist>
-       Definition: must be "wdog", "fatal", "ready", "handover", "stop-ack"
+       Definition: The interrupts needed depends on the compatible
+                   string:
+       qcom,msm8974-adsp-pil:
+       qcom,msm8996-adsp-pil:
+       qcom,msm8996-slpi-pil:
+       qcom,qcs404-adsp-pas:
+       qcom,qcs404-cdsp-pas:
+       qcom,sdm845-adsp-pas:
+       qcom,sdm845-cdsp-pas:
+                   must be "wdog", "fatal", "ready", "handover", "stop-ack"
+       qcom,qcs404-wcss-pas:
+                   must be "wdog", "fatal", "ready", "handover", "stop-ack",
+                   "shutdown-ack"
+
+- firmware-name:
+       Usage: optional
+       Value type: <string>
+       Definition: must list the relative firmware image path for the
+                   Hexagon Core.
 
 - clocks:
        Usage: required
index 9ff5b0309417cc49aa5b8c0adf97b801f01d53c3..41ca5df5be5ac78537ea6312214d00b08bafe3be 100644 (file)
@@ -28,24 +28,51 @@ on the Qualcomm Hexagon core.
 - interrupts-extended:
        Usage: required
        Value type: <prop-encoded-array>
-       Definition: must list the watchdog, fatal IRQs ready, handover and
-                   stop-ack IRQs
+       Definition: reference to the interrupts that match interrupt-names
 
 - interrupt-names:
        Usage: required
        Value type: <stringlist>
-       Definition: must be "wdog", "fatal", "ready", "handover", "stop-ack"
+       Definition: The interrupts needed depends on the the compatible
+                   string:
+       qcom,q6v5-pil:
+       qcom,ipq8074-wcss-pil:
+       qcom,msm8916-mss-pil:
+       qcom,msm8974-mss-pil:
+                   must be "wdog", "fatal", "ready", "handover", "stop-ack"
+       qcom,msm8996-mss-pil:
+       qcom,sdm845-mss-pil:
+                   must be "wdog", "fatal", "ready", "handover", "stop-ack",
+                   "shutdown-ack"
+
+- firmware-name:
+       Usage: optional
+       Value type: <stringlist>
+       Definition: must list the relative firmware image paths for mba and
+                   modem. They are used for booting and authenticating the
+                   Hexagon core.
 
 - clocks:
        Usage: required
        Value type: <phandle>
-       Definition: reference to the iface, bus and mem clocks to be held on
-                   behalf of the booting of the Hexagon core
+       Definition: reference to the clocks that match clock-names
 
 - clock-names:
        Usage: required
        Value type: <stringlist>
-       Definition: must be "iface", "bus", "mem"
+       Definition: The clocks needed depend on the compatible string:
+       qcom,ipq8074-wcss-pil:
+                   no clock names required
+       qcom,q6v5-pil:
+       qcom,msm8916-mss-pil:
+       qcom,msm8974-mss-pil:
+                   must be "iface", "bus", "mem", "xo"
+       qcom,msm8996-mss-pil:
+                   must be "iface", "bus", "mem", "xo", "gpll0_mss",
+                   "snoc_axi", "mnoc_axi", "pnoc", "qdss"
+       qcom,sdm845-mss-pil:
+                   must be "iface", "bus", "mem", "xo", "gpll0_mss",
+                   "snoc_axi", "mnoc_axi", "prng"
 
 - resets:
        Usage: required
@@ -65,6 +92,19 @@ on the Qualcomm Hexagon core.
                    must be "mss_restart", "pdc_reset" for the modem
                    sub-system on SDM845 SoCs
 
+For the compatible strings below the following supplies are required:
+  "qcom,q6v5-pil"
+  "qcom,msm8916-mss-pil",
+- cx-supply:
+- mx-supply:
+- pll-supply:
+       Usage: required
+       Value type: <phandle>
+       Definition: reference to the regulators to be held on behalf of the
+                   booting of the Hexagon core
+
+For the compatible string below the following supplies are required:
+  "qcom,msm8974-mss-pil"
 - cx-supply:
 - mss-supply:
 - mx-supply:
@@ -74,6 +114,33 @@ on the Qualcomm Hexagon core.
        Definition: reference to the regulators to be held on behalf of the
                    booting of the Hexagon core
 
+For the compatible string below the following supplies are required:
+  "qcom,msm8996-mss-pil"
+- pll-supply:
+       Usage: required
+       Value type: <phandle>
+       Definition: reference to the regulators to be held on behalf of the
+                   booting of the Hexagon core
+
+- power-domains:
+       Usage: required
+       Value type: <phandle>
+       Definition: reference to power-domains that match power-domain-names
+
+- power-domain-names:
+       Usage: required
+       Value type: <stringlist>
+       Definition: The power-domains needed depend on the compatible string:
+       qcom,q6v5-pil:
+       qcom,ipq8074-wcss-pil:
+       qcom,msm8916-mss-pil:
+       qcom,msm8974-mss-pil:
+                   no power-domain names required
+       qcom,msm8996-mss-pil:
+                   must be "cx", "mx"
+       qcom,sdm845-mss-pil:
+                   must be "cx", "mx", "mss", "load_state"
+
 - qcom,smem-states:
        Usage: required
        Value type: <phandle>
index 79374d1de3117fba0fb8a8ed4e8a1fa22b29627c..1f3ef9ee493c0ec781612b4c00817ab5dc3fe55c 100644 (file)
@@ -48,7 +48,7 @@
 
 /* list of clocks required by ADSP PIL */
 static const char * const adsp_clk_id[] = {
-       "sway_cbcr", "lpass_aon", "lpass_ahbs_aon_cbcr", "lpass_ahbm_aon_cbcr",
+       "sway_cbcr", "lpass_ahbs_aon_cbcr", "lpass_ahbm_aon_cbcr",
        "qdsp6ss_xo", "qdsp6ss_sleep", "qdsp6ss_core",
 };
 
@@ -439,6 +439,10 @@ static int adsp_probe(struct platform_device *pdev)
        adsp->sysmon = qcom_add_sysmon_subdev(rproc,
                                              desc->sysmon_name,
                                              desc->ssctl_id);
+       if (IS_ERR(adsp->sysmon)) {
+               ret = PTR_ERR(adsp->sysmon);
+               goto disable_pm;
+       }
 
        ret = rproc_add(rproc);
        if (ret)
index 01be7314e176f08da68dc33433fb6716097927c5..eacdf10fcfaf30fefb47f4dba1344b866762c7c9 100644 (file)
@@ -25,6 +25,8 @@
 #include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
+#include <linux/pm_domain.h>
+#include <linux/pm_runtime.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 #include <linux/remoteproc.h>
@@ -131,6 +133,8 @@ struct rproc_hexagon_res {
        char **proxy_clk_names;
        char **reset_clk_names;
        char **active_clk_names;
+       char **active_pd_names;
+       char **proxy_pd_names;
        int version;
        bool need_mem_protection;
        bool has_alt_reset;
@@ -156,9 +160,13 @@ struct q6v5 {
        struct clk *active_clks[8];
        struct clk *reset_clks[4];
        struct clk *proxy_clks[4];
+       struct device *active_pds[1];
+       struct device *proxy_pds[3];
        int active_clk_count;
        int reset_clk_count;
        int proxy_clk_count;
+       int active_pd_count;
+       int proxy_pd_count;
 
        struct reg_info active_regs[1];
        struct reg_info proxy_regs[3];
@@ -188,6 +196,7 @@ struct q6v5 {
        bool has_alt_reset;
        int mpss_perm;
        int mba_perm;
+       const char *hexagon_mdt_image;
        int version;
 };
 
@@ -321,6 +330,41 @@ static void q6v5_clk_disable(struct device *dev,
                clk_disable_unprepare(clks[i]);
 }
 
+static int q6v5_pds_enable(struct q6v5 *qproc, struct device **pds,
+                          size_t pd_count)
+{
+       int ret;
+       int i;
+
+       for (i = 0; i < pd_count; i++) {
+               dev_pm_genpd_set_performance_state(pds[i], INT_MAX);
+               ret = pm_runtime_get_sync(pds[i]);
+               if (ret < 0)
+                       goto unroll_pd_votes;
+       }
+
+       return 0;
+
+unroll_pd_votes:
+       for (i--; i >= 0; i--) {
+               dev_pm_genpd_set_performance_state(pds[i], 0);
+               pm_runtime_put(pds[i]);
+       }
+
+       return ret;
+};
+
+static void q6v5_pds_disable(struct q6v5 *qproc, struct device **pds,
+                            size_t pd_count)
+{
+       int i;
+
+       for (i = 0; i < pd_count; i++) {
+               dev_pm_genpd_set_performance_state(pds[i], 0);
+               pm_runtime_put(pds[i]);
+       }
+}
+
 static int q6v5_xfer_mem_ownership(struct q6v5 *qproc, int *current_perm,
                                   bool remote_owner, phys_addr_t addr,
                                   size_t size)
@@ -690,11 +734,23 @@ static int q6v5_mba_load(struct q6v5 *qproc)
 
        qcom_q6v5_prepare(&qproc->q6v5);
 
+       ret = q6v5_pds_enable(qproc, qproc->active_pds, qproc->active_pd_count);
+       if (ret < 0) {
+               dev_err(qproc->dev, "failed to enable active power domains\n");
+               goto disable_irqs;
+       }
+
+       ret = q6v5_pds_enable(qproc, qproc->proxy_pds, qproc->proxy_pd_count);
+       if (ret < 0) {
+               dev_err(qproc->dev, "failed to enable proxy power domains\n");
+               goto disable_active_pds;
+       }
+
        ret = q6v5_regulator_enable(qproc, qproc->proxy_regs,
                                    qproc->proxy_reg_count);
        if (ret) {
                dev_err(qproc->dev, "failed to enable proxy supplies\n");
-               goto disable_irqs;
+               goto disable_proxy_pds;
        }
 
        ret = q6v5_clk_enable(qproc->dev, qproc->proxy_clks,
@@ -791,6 +847,10 @@ disable_proxy_clk:
 disable_proxy_reg:
        q6v5_regulator_disable(qproc, qproc->proxy_regs,
                               qproc->proxy_reg_count);
+disable_proxy_pds:
+       q6v5_pds_disable(qproc, qproc->proxy_pds, qproc->proxy_pd_count);
+disable_active_pds:
+       q6v5_pds_disable(qproc, qproc->active_pds, qproc->active_pd_count);
 disable_irqs:
        qcom_q6v5_unprepare(&qproc->q6v5);
 
@@ -830,6 +890,7 @@ static void q6v5_mba_reclaim(struct q6v5 *qproc)
                         qproc->active_clk_count);
        q6v5_regulator_disable(qproc, qproc->active_regs,
                               qproc->active_reg_count);
+       q6v5_pds_disable(qproc, qproc->active_pds, qproc->active_pd_count);
 
        /* In case of failure or coredump scenario where reclaiming MBA memory
         * could not happen reclaim it here.
@@ -841,6 +902,8 @@ static void q6v5_mba_reclaim(struct q6v5 *qproc)
 
        ret = qcom_q6v5_unprepare(&qproc->q6v5);
        if (ret) {
+               q6v5_pds_disable(qproc, qproc->proxy_pds,
+                                qproc->proxy_pd_count);
                q6v5_clk_disable(qproc->dev, qproc->proxy_clks,
                                 qproc->proxy_clk_count);
                q6v5_regulator_disable(qproc, qproc->proxy_regs,
@@ -860,17 +923,26 @@ static int q6v5_mpss_load(struct q6v5 *qproc)
        phys_addr_t min_addr = PHYS_ADDR_MAX;
        phys_addr_t max_addr = 0;
        bool relocate = false;
-       char seg_name[10];
+       char *fw_name;
+       size_t fw_name_len;
        ssize_t offset;
        size_t size = 0;
        void *ptr;
        int ret;
        int i;
 
-       ret = request_firmware(&fw, "modem.mdt", qproc->dev);
+       fw_name_len = strlen(qproc->hexagon_mdt_image);
+       if (fw_name_len <= 4)
+               return -EINVAL;
+
+       fw_name = kstrdup(qproc->hexagon_mdt_image, GFP_KERNEL);
+       if (!fw_name)
+               return -ENOMEM;
+
+       ret = request_firmware(&fw, fw_name, qproc->dev);
        if (ret < 0) {
-               dev_err(qproc->dev, "unable to load modem.mdt\n");
-               return ret;
+               dev_err(qproc->dev, "unable to load %s\n", fw_name);
+               goto out;
        }
 
        /* Initialize the RMB validator */
@@ -918,10 +990,11 @@ static int q6v5_mpss_load(struct q6v5 *qproc)
                ptr = qproc->mpss_region + offset;
 
                if (phdr->p_filesz) {
-                       snprintf(seg_name, sizeof(seg_name), "modem.b%02d", i);
-                       ret = request_firmware(&seg_fw, seg_name, qproc->dev);
+                       /* Replace "xxx.xxx" with "xxx.bxx" */
+                       sprintf(fw_name + fw_name_len - 3, "b%02d", i);
+                       ret = request_firmware(&seg_fw, fw_name, qproc->dev);
                        if (ret) {
-                               dev_err(qproc->dev, "failed to load %s\n", seg_name);
+                               dev_err(qproc->dev, "failed to load %s\n", fw_name);
                                goto release_firmware;
                        }
 
@@ -960,6 +1033,8 @@ static int q6v5_mpss_load(struct q6v5 *qproc)
 
 release_firmware:
        release_firmware(fw);
+out:
+       kfree(fw_name);
 
        return ret < 0 ? ret : 0;
 }
@@ -1075,9 +1150,10 @@ static int qcom_q6v5_register_dump_segments(struct rproc *rproc,
        unsigned long i;
        int ret;
 
-       ret = request_firmware(&fw, "modem.mdt", qproc->dev);
+       ret = request_firmware(&fw, qproc->hexagon_mdt_image, qproc->dev);
        if (ret < 0) {
-               dev_err(qproc->dev, "unable to load modem.mdt\n");
+               dev_err(qproc->dev, "unable to load %s\n",
+                       qproc->hexagon_mdt_image);
                return ret;
        }
 
@@ -1121,6 +1197,7 @@ static void qcom_msa_handover(struct qcom_q6v5 *q6v5)
                         qproc->proxy_clk_count);
        q6v5_regulator_disable(qproc, qproc->proxy_regs,
                               qproc->proxy_reg_count);
+       q6v5_pds_disable(qproc, qproc->proxy_pds, qproc->proxy_pd_count);
 }
 
 static int q6v5_init_mem(struct q6v5 *qproc, struct platform_device *pdev)
@@ -1181,6 +1258,45 @@ static int q6v5_init_clocks(struct device *dev, struct clk **clks,
        return i;
 }
 
+static int q6v5_pds_attach(struct device *dev, struct device **devs,
+                          char **pd_names)
+{
+       size_t num_pds = 0;
+       int ret;
+       int i;
+
+       if (!pd_names)
+               return 0;
+
+       while (pd_names[num_pds])
+               num_pds++;
+
+       for (i = 0; i < num_pds; i++) {
+               devs[i] = dev_pm_domain_attach_by_name(dev, pd_names[i]);
+               if (IS_ERR(devs[i])) {
+                       ret = PTR_ERR(devs[i]);
+                       goto unroll_attach;
+               }
+       }
+
+       return num_pds;
+
+unroll_attach:
+       for (i--; i >= 0; i--)
+               dev_pm_domain_detach(devs[i], false);
+
+       return ret;
+};
+
+static void q6v5_pds_detach(struct q6v5 *qproc, struct device **pds,
+                           size_t pd_count)
+{
+       int i;
+
+       for (i = 0; i < pd_count; i++)
+               dev_pm_domain_detach(pds[i], false);
+}
+
 static int q6v5_init_reset(struct q6v5 *qproc)
 {
        qproc->mss_restart = devm_reset_control_get_exclusive(qproc->dev,
@@ -1253,6 +1369,7 @@ static int q6v5_probe(struct platform_device *pdev)
        const struct rproc_hexagon_res *desc;
        struct q6v5 *qproc;
        struct rproc *rproc;
+       const char *mba_image;
        int ret;
 
        desc = of_device_get_match_data(&pdev->dev);
@@ -1262,16 +1379,30 @@ static int q6v5_probe(struct platform_device *pdev)
        if (desc->need_mem_protection && !qcom_scm_is_available())
                return -EPROBE_DEFER;
 
+       mba_image = desc->hexagon_mba_image;
+       ret = of_property_read_string_index(pdev->dev.of_node, "firmware-name",
+                                           0, &mba_image);
+       if (ret < 0 && ret != -EINVAL)
+               return ret;
+
        rproc = rproc_alloc(&pdev->dev, pdev->name, &q6v5_ops,
-                           desc->hexagon_mba_image, sizeof(*qproc));
+                           mba_image, sizeof(*qproc));
        if (!rproc) {
                dev_err(&pdev->dev, "failed to allocate rproc\n");
                return -ENOMEM;
        }
 
+       rproc->auto_boot = false;
+
        qproc = (struct q6v5 *)rproc->priv;
        qproc->dev = &pdev->dev;
        qproc->rproc = rproc;
+       qproc->hexagon_mdt_image = "modem.mdt";
+       ret = of_property_read_string_index(pdev->dev.of_node, "firmware-name",
+                                           1, &qproc->hexagon_mdt_image);
+       if (ret < 0 && ret != -EINVAL)
+               return ret;
+
        platform_set_drvdata(pdev, qproc);
 
        ret = q6v5_init_mem(qproc, pdev);
@@ -1322,10 +1453,26 @@ static int q6v5_probe(struct platform_device *pdev)
        }
        qproc->active_reg_count = ret;
 
+       ret = q6v5_pds_attach(&pdev->dev, qproc->active_pds,
+                             desc->active_pd_names);
+       if (ret < 0) {
+               dev_err(&pdev->dev, "Failed to attach active power domains\n");
+               goto free_rproc;
+       }
+       qproc->active_pd_count = ret;
+
+       ret = q6v5_pds_attach(&pdev->dev, qproc->proxy_pds,
+                             desc->proxy_pd_names);
+       if (ret < 0) {
+               dev_err(&pdev->dev, "Failed to init power domains\n");
+               goto detach_active_pds;
+       }
+       qproc->proxy_pd_count = ret;
+
        qproc->has_alt_reset = desc->has_alt_reset;
        ret = q6v5_init_reset(qproc);
        if (ret)
-               goto free_rproc;
+               goto detach_proxy_pds;
 
        qproc->version = desc->version;
        qproc->need_mem_protection = desc->need_mem_protection;
@@ -1333,7 +1480,7 @@ static int q6v5_probe(struct platform_device *pdev)
        ret = qcom_q6v5_init(&qproc->q6v5, pdev, rproc, MPSS_CRASH_REASON_SMEM,
                             qcom_msa_handover);
        if (ret)
-               goto free_rproc;
+               goto detach_proxy_pds;
 
        qproc->mpss_perm = BIT(QCOM_SCM_VMID_HLOS);
        qproc->mba_perm = BIT(QCOM_SCM_VMID_HLOS);
@@ -1341,13 +1488,21 @@ static int q6v5_probe(struct platform_device *pdev)
        qcom_add_smd_subdev(rproc, &qproc->smd_subdev);
        qcom_add_ssr_subdev(rproc, &qproc->ssr_subdev, "mpss");
        qproc->sysmon = qcom_add_sysmon_subdev(rproc, "modem", 0x12);
+       if (IS_ERR(qproc->sysmon)) {
+               ret = PTR_ERR(qproc->sysmon);
+               goto detach_proxy_pds;
+       }
 
        ret = rproc_add(rproc);
        if (ret)
-               goto free_rproc;
+               goto detach_proxy_pds;
 
        return 0;
 
+detach_proxy_pds:
+       q6v5_pds_detach(qproc, qproc->proxy_pds, qproc->proxy_pd_count);
+detach_active_pds:
+       q6v5_pds_detach(qproc, qproc->active_pds, qproc->active_pd_count);
 free_rproc:
        rproc_free(rproc);
 
@@ -1364,6 +1519,10 @@ static int q6v5_remove(struct platform_device *pdev)
        qcom_remove_glink_subdev(qproc->rproc, &qproc->glink_subdev);
        qcom_remove_smd_subdev(qproc->rproc, &qproc->smd_subdev);
        qcom_remove_ssr_subdev(qproc->rproc, &qproc->ssr_subdev);
+
+       q6v5_pds_detach(qproc, qproc->active_pds, qproc->active_pd_count);
+       q6v5_pds_detach(qproc, qproc->proxy_pds, qproc->proxy_pd_count);
+
        rproc_free(qproc->rproc);
 
        return 0;
@@ -1388,6 +1547,16 @@ static const struct rproc_hexagon_res sdm845_mss = {
                        "mnoc_axi",
                        NULL
        },
+       .active_pd_names = (char*[]){
+                       "load_state",
+                       NULL
+       },
+       .proxy_pd_names = (char*[]){
+                       "cx",
+                       "mx",
+                       "mss",
+                       NULL
+       },
        .need_mem_protection = true,
        .has_alt_reset = true,
        .version = MSS_SDM845,
@@ -1395,16 +1564,26 @@ static const struct rproc_hexagon_res sdm845_mss = {
 
 static const struct rproc_hexagon_res msm8996_mss = {
        .hexagon_mba_image = "mba.mbn",
+       .proxy_supply = (struct qcom_mss_reg_res[]) {
+               {
+                       .supply = "pll",
+                       .uA = 100000,
+               },
+               {}
+       },
        .proxy_clk_names = (char*[]){
                        "xo",
                        "pnoc",
+                       "qdss",
                        NULL
        },
        .active_clk_names = (char*[]){
                        "iface",
                        "bus",
                        "mem",
-                       "gpll0_mss_clk",
+                       "gpll0_mss",
+                       "snoc_axi",
+                       "mnoc_axi",
                        NULL
        },
        .need_mem_protection = true,
index b1e63fcd5fdf453672819d699cd064fffbcac704..f280f196d007c776d4783d5e793fa789382687c0 100644 (file)
@@ -258,6 +258,7 @@ static int adsp_probe(struct platform_device *pdev)
        const struct adsp_data *desc;
        struct qcom_adsp *adsp;
        struct rproc *rproc;
+       const char *fw_name;
        int ret;
 
        desc = of_device_get_match_data(&pdev->dev);
@@ -267,8 +268,14 @@ static int adsp_probe(struct platform_device *pdev)
        if (!qcom_scm_is_available())
                return -EPROBE_DEFER;
 
+       fw_name = desc->firmware_name;
+       ret = of_property_read_string(pdev->dev.of_node, "firmware-name",
+                                     &fw_name);
+       if (ret < 0 && ret != -EINVAL)
+               return ret;
+
        rproc = rproc_alloc(&pdev->dev, pdev->name, &adsp_ops,
-                           desc->firmware_name, sizeof(*adsp));
+                           fw_name, sizeof(*adsp));
        if (!rproc) {
                dev_err(&pdev->dev, "unable to allocate remoteproc\n");
                return -ENOMEM;
@@ -304,6 +311,10 @@ static int adsp_probe(struct platform_device *pdev)
        adsp->sysmon = qcom_add_sysmon_subdev(rproc,
                                              desc->sysmon_name,
                                              desc->ssctl_id);
+       if (IS_ERR(adsp->sysmon)) {
+               ret = PTR_ERR(adsp->sysmon);
+               goto free_rproc;
+       }
 
        ret = rproc_add(rproc);
        if (ret)
index e976a602b0155126723de85ec0afa38c666a2c4f..c231314eab6672dcc714d2256809a663a8a08393 100644 (file)
@@ -6,8 +6,9 @@
 #include <linux/module.h>
 #include <linux/notifier.h>
 #include <linux/slab.h>
+#include <linux/interrupt.h>
 #include <linux/io.h>
-#include <linux/notifier.h>
+#include <linux/of_irq.h>
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
 #include <linux/remoteproc/qcom_rproc.h>
@@ -25,6 +26,7 @@ struct qcom_sysmon {
 
        const char *name;
 
+       int shutdown_irq;
        int ssctl_version;
        int ssctl_instance;
 
@@ -34,6 +36,8 @@ struct qcom_sysmon {
 
        struct rpmsg_endpoint *ept;
        struct completion comp;
+       struct completion ind_comp;
+       struct completion shutdown_comp;
        struct mutex lock;
 
        bool ssr_ack;
@@ -137,6 +141,7 @@ static int sysmon_callback(struct rpmsg_device *rpdev, void *data, int count,
 }
 
 #define SSCTL_SHUTDOWN_REQ             0x21
+#define SSCTL_SHUTDOWN_READY_IND       0x21
 #define SSCTL_SUBSYS_EVENT_REQ         0x23
 
 #define SSCTL_MAX_MSG_LEN              7
@@ -252,6 +257,29 @@ static struct qmi_elem_info ssctl_subsys_event_resp_ei[] = {
        {}
 };
 
+static struct qmi_elem_info ssctl_shutdown_ind_ei[] = {
+       {}
+};
+
+static void sysmon_ind_cb(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
+                         struct qmi_txn *txn, const void *data)
+{
+       struct qcom_sysmon *sysmon = container_of(qmi, struct qcom_sysmon, qmi);
+
+       complete(&sysmon->ind_comp);
+}
+
+static struct qmi_msg_handler qmi_indication_handler[] = {
+       {
+               .type = QMI_INDICATION,
+               .msg_id = SSCTL_SHUTDOWN_READY_IND,
+               .ei = ssctl_shutdown_ind_ei,
+               .decoded_size = 0,
+               .fn = sysmon_ind_cb
+       },
+       {}
+};
+
 /**
  * ssctl_request_shutdown() - request shutdown via SSCTL QMI service
  * @sysmon:    sysmon context
@@ -262,6 +290,8 @@ static void ssctl_request_shutdown(struct qcom_sysmon *sysmon)
        struct qmi_txn txn;
        int ret;
 
+       reinit_completion(&sysmon->ind_comp);
+       reinit_completion(&sysmon->shutdown_comp);
        ret = qmi_txn_init(&sysmon->qmi, &txn, ssctl_shutdown_resp_ei, &resp);
        if (ret < 0) {
                dev_err(sysmon->dev, "failed to allocate QMI txn\n");
@@ -283,6 +313,17 @@ static void ssctl_request_shutdown(struct qcom_sysmon *sysmon)
                dev_err(sysmon->dev, "shutdown request failed\n");
        else
                dev_dbg(sysmon->dev, "shutdown request completed\n");
+
+       if (sysmon->shutdown_irq > 0) {
+               ret = wait_for_completion_timeout(&sysmon->shutdown_comp,
+                                                 10 * HZ);
+               if (!ret) {
+                       ret = try_wait_for_completion(&sysmon->ind_comp);
+                       if (!ret)
+                               dev_err(sysmon->dev,
+                                       "timeout waiting for shutdown ack\n");
+               }
+       }
 }
 
 /**
@@ -432,6 +473,15 @@ static int sysmon_notify(struct notifier_block *nb, unsigned long event,
        return NOTIFY_DONE;
 }
 
+static irqreturn_t sysmon_shutdown_interrupt(int irq, void *data)
+{
+       struct qcom_sysmon *sysmon = data;
+
+       complete(&sysmon->shutdown_comp);
+
+       return IRQ_HANDLED;
+}
+
 /**
  * qcom_add_sysmon_subdev() - create a sysmon subdev for the given remoteproc
  * @rproc:     rproc context to associate the subdev with
@@ -449,7 +499,7 @@ struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,
 
        sysmon = kzalloc(sizeof(*sysmon), GFP_KERNEL);
        if (!sysmon)
-               return NULL;
+               return ERR_PTR(-ENOMEM);
 
        sysmon->dev = rproc->dev.parent;
        sysmon->rproc = rproc;
@@ -458,13 +508,37 @@ struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,
        sysmon->ssctl_instance = ssctl_instance;
 
        init_completion(&sysmon->comp);
+       init_completion(&sysmon->ind_comp);
+       init_completion(&sysmon->shutdown_comp);
        mutex_init(&sysmon->lock);
 
-       ret = qmi_handle_init(&sysmon->qmi, SSCTL_MAX_MSG_LEN, &ssctl_ops, NULL);
+       sysmon->shutdown_irq = of_irq_get_byname(sysmon->dev->of_node,
+                                                "shutdown-ack");
+       if (sysmon->shutdown_irq < 0) {
+               if (sysmon->shutdown_irq != -ENODATA) {
+                       dev_err(sysmon->dev,
+                               "failed to retrieve shutdown-ack IRQ\n");
+                       return ERR_PTR(sysmon->shutdown_irq);
+               }
+       } else {
+               ret = devm_request_threaded_irq(sysmon->dev,
+                                               sysmon->shutdown_irq,
+                                               NULL, sysmon_shutdown_interrupt,
+                                               IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                               "q6v5 shutdown-ack", sysmon);
+               if (ret) {
+                       dev_err(sysmon->dev,
+                               "failed to acquire shutdown-ack IRQ\n");
+                       return ERR_PTR(ret);
+               }
+       }
+
+       ret = qmi_handle_init(&sysmon->qmi, SSCTL_MAX_MSG_LEN, &ssctl_ops,
+                             qmi_indication_handler);
        if (ret < 0) {
                dev_err(sysmon->dev, "failed to initialize qmi handle\n");
                kfree(sysmon);
-               return NULL;
+               return ERR_PTR(ret);
        }
 
        qmi_add_lookup(&sysmon->qmi, 43, 0, 0);
index b0e07e9f42d5698e64baa7897d75460c28a89690..adcce523971e6522ae0d55bb3baf34936387bd63 100644 (file)
@@ -553,6 +553,10 @@ static int wcnss_probe(struct platform_device *pdev)
 
        qcom_add_smd_subdev(rproc, &wcnss->smd_subdev);
        wcnss->sysmon = qcom_add_sysmon_subdev(rproc, "wcnss", WCNSS_SSCTL_ID);
+       if (IS_ERR(wcnss->sysmon)) {
+               ret = PTR_ERR(wcnss->sysmon);
+               goto free_rproc;
+       }
 
        ret = rproc_add(rproc);
        if (ret)
@@ -622,5 +626,5 @@ static void __exit wcnss_exit(void)
 }
 module_exit(wcnss_exit);
 
-MODULE_DESCRIPTION("Qualcomm Peripherial Image Loader for Wireless Subsystem");
+MODULE_DESCRIPTION("Qualcomm Peripheral Image Loader for Wireless Subsystem");
 MODULE_LICENSE("GPL v2");
index 54ec38fc5dca621ad5d4d2b10e4f7fc0afa647b4..48feebd6d0a2dd88b3dfefde33b6182fc2d0b33a 100644 (file)
 #include <linux/idr.h>
 #include <linux/elf.h>
 #include <linux/crc32.h>
+#include <linux/of_reserved_mem.h>
 #include <linux/virtio_ids.h>
 #include <linux/virtio_ring.h>
 #include <asm/byteorder.h>
+#include <linux/platform_device.h>
 
 #include "remoteproc_internal.h"
 
+#define HIGH_BITS_MASK 0xFFFFFFFF00000000ULL
+
 static DEFINE_MUTEX(rproc_list_mutex);
 static LIST_HEAD(rproc_list);
 
@@ -145,7 +149,7 @@ static void rproc_disable_iommu(struct rproc *rproc)
        iommu_domain_free(domain);
 }
 
-static phys_addr_t rproc_va_to_pa(void *cpu_addr)
+phys_addr_t rproc_va_to_pa(void *cpu_addr)
 {
        /*
         * Return physical address according to virtual address location
@@ -160,6 +164,7 @@ static phys_addr_t rproc_va_to_pa(void *cpu_addr)
        WARN_ON(!virt_addr_valid(cpu_addr));
        return virt_to_phys(cpu_addr);
 }
+EXPORT_SYMBOL(rproc_va_to_pa);
 
 /**
  * rproc_da_to_va() - lookup the kernel virtual address for a remoteproc address
@@ -204,6 +209,10 @@ void *rproc_da_to_va(struct rproc *rproc, u64 da, int len)
        list_for_each_entry(carveout, &rproc->carveouts, node) {
                int offset = da - carveout->da;
 
+               /*  Verify that carveout is allocated */
+               if (!carveout->va)
+                       continue;
+
                /* try next carveout if da is too small */
                if (offset < 0)
                        continue;
@@ -272,25 +281,27 @@ rproc_find_carveout_by_name(struct rproc *rproc, const char *name, ...)
  * @len: associated area size
  *
  * This function is a helper function to verify requested device area (couple
- * da, len) is part of specified carevout.
+ * da, len) is part of specified carveout.
+ * If da is not set (defined as FW_RSC_ADDR_ANY), only requested length is
+ * checked.
  *
- * Return: 0 if carveout match request else -ENOMEM
+ * Return: 0 if carveout matches request else error
  */
-int rproc_check_carveout_da(struct rproc *rproc, struct rproc_mem_entry *mem,
-                           u32 da, u32 len)
+static int rproc_check_carveout_da(struct rproc *rproc,
+                                  struct rproc_mem_entry *mem, u32 da, u32 len)
 {
        struct device *dev = &rproc->dev;
-       int delta = 0;
+       int delta;
 
        /* Check requested resource length */
        if (len > mem->len) {
                dev_err(dev, "Registered carveout doesn't fit len request\n");
-               return -ENOMEM;
+               return -EINVAL;
        }
 
        if (da != FW_RSC_ADDR_ANY && mem->da == FW_RSC_ADDR_ANY) {
-               /* Update existing carveout da */
-               mem->da = da;
+               /* Address doesn't match registered carveout configuration */
+               return -EINVAL;
        } else if (da != FW_RSC_ADDR_ANY && mem->da != FW_RSC_ADDR_ANY) {
                delta = da - mem->da;
 
@@ -298,13 +309,13 @@ int rproc_check_carveout_da(struct rproc *rproc, struct rproc_mem_entry *mem,
                if (delta < 0) {
                        dev_err(dev,
                                "Registered carveout doesn't fit da request\n");
-                       return -ENOMEM;
+                       return -EINVAL;
                }
 
                if (delta + len > mem->len) {
                        dev_err(dev,
                                "Registered carveout doesn't fit len request\n");
-                       return -ENOMEM;
+                       return -EINVAL;
                }
        }
 
@@ -418,8 +429,25 @@ static int rproc_vdev_do_start(struct rproc_subdev *subdev)
 static void rproc_vdev_do_stop(struct rproc_subdev *subdev, bool crashed)
 {
        struct rproc_vdev *rvdev = container_of(subdev, struct rproc_vdev, subdev);
+       int ret;
 
-       rproc_remove_virtio_dev(rvdev);
+       ret = device_for_each_child(&rvdev->dev, NULL, rproc_remove_virtio_dev);
+       if (ret)
+               dev_warn(&rvdev->dev, "can't remove vdev child device: %d\n", ret);
+}
+
+/**
+ * rproc_rvdev_release() - release the existence of a rvdev
+ *
+ * @dev: the subdevice's dev
+ */
+static void rproc_rvdev_release(struct device *dev)
+{
+       struct rproc_vdev *rvdev = container_of(dev, struct rproc_vdev, dev);
+
+       of_reserved_mem_device_release(dev);
+
+       kfree(rvdev);
 }
 
 /**
@@ -455,6 +483,7 @@ static int rproc_handle_vdev(struct rproc *rproc, struct fw_rsc_vdev *rsc,
        struct device *dev = &rproc->dev;
        struct rproc_vdev *rvdev;
        int i, ret;
+       char name[16];
 
        /* make sure resource isn't truncated */
        if (sizeof(*rsc) + rsc->num_of_vrings * sizeof(struct fw_rsc_vdev_vring)
@@ -488,6 +517,29 @@ static int rproc_handle_vdev(struct rproc *rproc, struct fw_rsc_vdev *rsc,
        rvdev->rproc = rproc;
        rvdev->index = rproc->nb_vdev++;
 
+       /* Initialise vdev subdevice */
+       snprintf(name, sizeof(name), "vdev%dbuffer", rvdev->index);
+       rvdev->dev.parent = rproc->dev.parent;
+       rvdev->dev.release = rproc_rvdev_release;
+       dev_set_name(&rvdev->dev, "%s#%s", dev_name(rvdev->dev.parent), name);
+       dev_set_drvdata(&rvdev->dev, rvdev);
+
+       ret = device_register(&rvdev->dev);
+       if (ret) {
+               put_device(&rvdev->dev);
+               return ret;
+       }
+       /* Make device dma capable by inheriting from parent's capabilities */
+       set_dma_ops(&rvdev->dev, get_dma_ops(rproc->dev.parent));
+
+       ret = dma_coerce_mask_and_coherent(&rvdev->dev,
+                                          dma_get_mask(rproc->dev.parent));
+       if (ret) {
+               dev_warn(dev,
+                        "Failed to set DMA mask %llx. Trying to continue... %x\n",
+                        dma_get_mask(rproc->dev.parent), ret);
+       }
+
        /* parse the vrings */
        for (i = 0; i < rsc->num_of_vrings; i++) {
                ret = rproc_parse_vring(rvdev, rsc, i);
@@ -518,7 +570,7 @@ unwind_vring_allocations:
        for (i--; i >= 0; i--)
                rproc_free_vring(&rvdev->vring[i]);
 free_rvdev:
-       kfree(rvdev);
+       device_unregister(&rvdev->dev);
        return ret;
 }
 
@@ -536,7 +588,7 @@ void rproc_vdev_release(struct kref *ref)
 
        rproc_remove_subdev(rproc, &rvdev->subdev);
        list_del(&rvdev->node);
-       kfree(rvdev);
+       device_unregister(&rvdev->dev);
 }
 
 /**
@@ -558,9 +610,8 @@ void rproc_vdev_release(struct kref *ref)
 static int rproc_handle_trace(struct rproc *rproc, struct fw_rsc_trace *rsc,
                              int offset, int avail)
 {
-       struct rproc_mem_entry *trace;
+       struct rproc_debug_trace *trace;
        struct device *dev = &rproc->dev;
-       void *ptr;
        char name[15];
 
        if (sizeof(*rsc) > avail) {
@@ -574,28 +625,23 @@ static int rproc_handle_trace(struct rproc *rproc, struct fw_rsc_trace *rsc,
                return -EINVAL;
        }
 
-       /* what's the kernel address of this resource ? */
-       ptr = rproc_da_to_va(rproc, rsc->da, rsc->len);
-       if (!ptr) {
-               dev_err(dev, "erroneous trace resource entry\n");
-               return -EINVAL;
-       }
-
        trace = kzalloc(sizeof(*trace), GFP_KERNEL);
        if (!trace)
                return -ENOMEM;
 
        /* set the trace buffer dma properties */
-       trace->len = rsc->len;
-       trace->va = ptr;
+       trace->trace_mem.len = rsc->len;
+       trace->trace_mem.da = rsc->da;
+
+       /* set pointer on rproc device */
+       trace->rproc = rproc;
 
        /* make sure snprintf always null terminates, even if truncating */
        snprintf(name, sizeof(name), "trace%d", rproc->num_traces);
 
        /* create the debugfs entry */
-       trace->priv = rproc_create_trace_file(name, rproc, trace);
-       if (!trace->priv) {
-               trace->va = NULL;
+       trace->tfile = rproc_create_trace_file(name, rproc, trace);
+       if (!trace->tfile) {
                kfree(trace);
                return -EINVAL;
        }
@@ -604,8 +650,8 @@ static int rproc_handle_trace(struct rproc *rproc, struct fw_rsc_trace *rsc,
 
        rproc->num_traces++;
 
-       dev_dbg(dev, "%s added: va %pK, da 0x%x, len 0x%x\n",
-               name, ptr, rsc->da, rsc->len);
+       dev_dbg(dev, "%s added: da 0x%x, len 0x%x\n",
+               name, rsc->da, rsc->len);
 
        return 0;
 }
@@ -715,6 +761,18 @@ static int rproc_alloc_carveout(struct rproc *rproc,
        dev_dbg(dev, "carveout va %pK, dma %pad, len 0x%x\n",
                va, &dma, mem->len);
 
+       if (mem->da != FW_RSC_ADDR_ANY && !rproc->domain) {
+               /*
+                * Check requested da is equal to dma address
+                * and print a warn message in case of missalignment.
+                * Don't stop rproc_start sequence as coprocessor may
+                * build pa to da translation on its side.
+                */
+               if (mem->da != (u32)dma)
+                       dev_warn(dev->parent,
+                                "Allocated carveout doesn't fit device address request\n");
+       }
+
        /*
         * Ok, this is non-standard.
         *
@@ -732,15 +790,7 @@ static int rproc_alloc_carveout(struct rproc *rproc,
         * to use the iommu-based DMA API: we expect 'dma' to contain the
         * physical address in this case.
         */
-
-       if (mem->da != FW_RSC_ADDR_ANY) {
-               if (!rproc->domain) {
-                       dev_err(dev->parent,
-                               "Bad carveout rsc configuration\n");
-                       ret = -ENOMEM;
-                       goto dma_free;
-               }
-
+       if (mem->da != FW_RSC_ADDR_ANY && rproc->domain) {
                mapping = kzalloc(sizeof(*mapping), GFP_KERNEL);
                if (!mapping) {
                        ret = -ENOMEM;
@@ -767,11 +817,17 @@ static int rproc_alloc_carveout(struct rproc *rproc,
 
                dev_dbg(dev, "carveout mapped 0x%x to %pad\n",
                        mem->da, &dma);
-       } else {
+       }
+
+       if (mem->da == FW_RSC_ADDR_ANY) {
+               /* Update device address as undefined by requester */
+               if ((u64)dma & HIGH_BITS_MASK)
+                       dev_warn(dev, "DMA address cast in 32bit to fit resource table format\n");
+
                mem->da = (u32)dma;
        }
 
-       mem->dma = (u32)dma;
+       mem->dma = dma;
        mem->va = va;
 
        return 0;
@@ -900,7 +956,8 @@ EXPORT_SYMBOL(rproc_add_carveout);
  * @dma: dma address
  * @len: memory carveout length
  * @da: device address
- * @release: memory carveout function
+ * @alloc: memory carveout allocation function
+ * @release: memory carveout release function
  * @name: carveout name
  *
  * This function allocates a rproc_mem_entry struct and fill it with parameters
@@ -1110,6 +1167,7 @@ static int rproc_alloc_registered_carveouts(struct rproc *rproc)
        struct rproc_mem_entry *entry, *tmp;
        struct fw_rsc_carveout *rsc;
        struct device *dev = &rproc->dev;
+       u64 pa;
        int ret;
 
        list_for_each_entry_safe(entry, tmp, &rproc->carveouts, node) {
@@ -1146,10 +1204,15 @@ static int rproc_alloc_registered_carveouts(struct rproc *rproc)
 
                        /* Use va if defined else dma to generate pa */
                        if (entry->va)
-                               rsc->pa = (u32)rproc_va_to_pa(entry->va);
+                               pa = (u64)rproc_va_to_pa(entry->va);
                        else
-                               rsc->pa = (u32)entry->dma;
+                               pa = (u64)entry->dma;
+
+                       if (((u64)pa) & HIGH_BITS_MASK)
+                               dev_warn(dev,
+                                        "Physical address cast in 32bit to fit resource table format\n");
 
+                       rsc->pa = (u32)pa;
                        rsc->da = entry->da;
                        rsc->len = entry->len;
                }
@@ -1182,15 +1245,16 @@ static void rproc_coredump_cleanup(struct rproc *rproc)
 static void rproc_resource_cleanup(struct rproc *rproc)
 {
        struct rproc_mem_entry *entry, *tmp;
+       struct rproc_debug_trace *trace, *ttmp;
        struct rproc_vdev *rvdev, *rvtmp;
        struct device *dev = &rproc->dev;
 
        /* clean up debugfs trace entries */
-       list_for_each_entry_safe(entry, tmp, &rproc->traces, node) {
-               rproc_remove_trace_file(entry->priv);
+       list_for_each_entry_safe(trace, ttmp, &rproc->traces, node) {
+               rproc_remove_trace_file(trace->tfile);
                rproc->num_traces--;
-               list_del(&entry->node);
-               kfree(entry);
+               list_del(&trace->node);
+               kfree(trace);
        }
 
        /* clean up iommu mapping entries */
index e90135c64af0761ec37d392921a33aa602829f0f..6da934b8dc4be29a0d44cee03d64c5842fcd4d18 100644 (file)
@@ -47,10 +47,23 @@ static struct dentry *rproc_dbg;
 static ssize_t rproc_trace_read(struct file *filp, char __user *userbuf,
                                size_t count, loff_t *ppos)
 {
-       struct rproc_mem_entry *trace = filp->private_data;
-       int len = strnlen(trace->va, trace->len);
+       struct rproc_debug_trace *data = filp->private_data;
+       struct rproc_mem_entry *trace = &data->trace_mem;
+       void *va;
+       char buf[100];
+       int len;
+
+       va = rproc_da_to_va(data->rproc, trace->da, trace->len);
 
-       return simple_read_from_buffer(userbuf, count, ppos, trace->va, len);
+       if (!va) {
+               len = scnprintf(buf, sizeof(buf), "Trace %s not available\n",
+                               trace->name);
+               va = buf;
+       } else {
+               len = strnlen(va, trace->len);
+       }
+
+       return simple_read_from_buffer(userbuf, count, ppos, va, len);
 }
 
 static const struct file_operations trace_rproc_ops = {
@@ -155,6 +168,30 @@ static const struct file_operations rproc_recovery_ops = {
        .llseek = generic_file_llseek,
 };
 
+/* expose the crash trigger via debugfs */
+static ssize_t
+rproc_crash_write(struct file *filp, const char __user *user_buf,
+                 size_t count, loff_t *ppos)
+{
+       struct rproc *rproc = filp->private_data;
+       unsigned int type;
+       int ret;
+
+       ret = kstrtouint_from_user(user_buf, count, 0, &type);
+       if (ret < 0)
+               return ret;
+
+       rproc_report_crash(rproc, type);
+
+       return count;
+}
+
+static const struct file_operations rproc_crash_ops = {
+       .write = rproc_crash_write,
+       .open = simple_open,
+       .llseek = generic_file_llseek,
+};
+
 /* Expose resource table content via debugfs */
 static int rproc_rsc_table_show(struct seq_file *seq, void *p)
 {
@@ -288,7 +325,7 @@ void rproc_remove_trace_file(struct dentry *tfile)
 }
 
 struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,
-                                      struct rproc_mem_entry *trace)
+                                      struct rproc_debug_trace *trace)
 {
        struct dentry *tfile;
 
@@ -325,6 +362,8 @@ void rproc_create_debug_dir(struct rproc *rproc)
                            rproc, &rproc_name_ops);
        debugfs_create_file("recovery", 0400, rproc->dbg_dir,
                            rproc, &rproc_recovery_ops);
+       debugfs_create_file("crash", 0200, rproc->dbg_dir,
+                           rproc, &rproc_crash_ops);
        debugfs_create_file("resource_table", 0400, rproc->dbg_dir,
                            rproc, &rproc_rsc_table_ops);
        debugfs_create_file("carveout_memories", 0400, rproc->dbg_dir,
index f6cad243d7cac9a7255be1107db5981d5ab3eff2..45ff76a06c72bec26d18f3d8753686d0346a86c1 100644 (file)
 
 struct rproc;
 
+struct rproc_debug_trace {
+       struct rproc *rproc;
+       struct dentry *tfile;
+       struct list_head node;
+       struct rproc_mem_entry trace_mem;
+};
+
 /* from remoteproc_core.c */
 void rproc_release(struct kref *kref);
 irqreturn_t rproc_vq_interrupt(struct rproc *rproc, int vq_id);
@@ -32,12 +39,12 @@ void rproc_vdev_release(struct kref *ref);
 
 /* from remoteproc_virtio.c */
 int rproc_add_virtio_dev(struct rproc_vdev *rvdev, int id);
-void rproc_remove_virtio_dev(struct rproc_vdev *rvdev);
+int rproc_remove_virtio_dev(struct device *dev, void *data);
 
 /* from remoteproc_debugfs.c */
 void rproc_remove_trace_file(struct dentry *tfile);
 struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,
-                                      struct rproc_mem_entry *trace);
+                                      struct rproc_debug_trace *trace);
 void rproc_delete_debug_dir(struct rproc *rproc);
 void rproc_create_debug_dir(struct rproc *rproc);
 void rproc_init_debugfs(void);
@@ -52,6 +59,7 @@ void rproc_free_vring(struct rproc_vring *rvring);
 int rproc_alloc_vring(struct rproc_vdev *rvdev, int i);
 
 void *rproc_da_to_va(struct rproc *rproc, u64 da, int len);
+phys_addr_t rproc_va_to_pa(void *cpu_addr);
 int rproc_trigger_recovery(struct rproc *rproc);
 
 int rproc_elf_sanity_check(struct rproc *rproc, const struct firmware *fw);
index 2d7cd344f3bffbc3b5960078c86f77b79d32743b..44774de6f17b067c15540ecc67a3d86db77eb435 100644 (file)
@@ -17,7 +17,9 @@
  * GNU General Public License for more details.
  */
 
+#include <linux/dma-mapping.h>
 #include <linux/export.h>
+#include <linux/of_reserved_mem.h>
 #include <linux/remoteproc.h>
 #include <linux/virtio.h>
 #include <linux/virtio_config.h>
@@ -316,6 +318,8 @@ static void rproc_virtio_dev_release(struct device *dev)
        struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
        struct rproc *rproc = vdev_to_rproc(vdev);
 
+       kfree(vdev);
+
        kref_put(&rvdev->refcount, rproc_vdev_release);
 
        put_device(&rproc->dev);
@@ -333,10 +337,53 @@ static void rproc_virtio_dev_release(struct device *dev)
 int rproc_add_virtio_dev(struct rproc_vdev *rvdev, int id)
 {
        struct rproc *rproc = rvdev->rproc;
-       struct device *dev = &rproc->dev;
-       struct virtio_device *vdev = &rvdev->vdev;
+       struct device *dev = &rvdev->dev;
+       struct virtio_device *vdev;
+       struct rproc_mem_entry *mem;
        int ret;
 
+       /* Try to find dedicated vdev buffer carveout */
+       mem = rproc_find_carveout_by_name(rproc, "vdev%dbuffer", rvdev->index);
+       if (mem) {
+               phys_addr_t pa;
+
+               if (mem->of_resm_idx != -1) {
+                       struct device_node *np = rproc->dev.parent->of_node;
+
+                       /* Associate reserved memory to vdev device */
+                       ret = of_reserved_mem_device_init_by_idx(dev, np,
+                                                                mem->of_resm_idx);
+                       if (ret) {
+                               dev_err(dev, "Can't associate reserved memory\n");
+                               goto out;
+                       }
+               } else {
+                       if (mem->va) {
+                               dev_warn(dev, "vdev %d buffer already mapped\n",
+                                        rvdev->index);
+                               pa = rproc_va_to_pa(mem->va);
+                       } else {
+                               /* Use dma address as carveout no memmapped yet */
+                               pa = (phys_addr_t)mem->dma;
+                       }
+
+                       /* Associate vdev buffer memory pool to vdev subdev */
+                       ret = dma_declare_coherent_memory(dev, pa,
+                                                          mem->da,
+                                                          mem->len);
+                       if (ret < 0) {
+                               dev_err(dev, "Failed to associate buffer\n");
+                               goto out;
+                       }
+               }
+       }
+
+       /* Allocate virtio device */
+       vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
+       if (!vdev) {
+               ret = -ENOMEM;
+               goto out;
+       }
        vdev->id.device = id,
        vdev->config = &rproc_virtio_config_ops,
        vdev->dev.parent = dev;
@@ -370,11 +417,15 @@ out:
 
 /**
  * rproc_remove_virtio_dev() - remove an rproc-induced virtio device
- * @rvdev: the remote vdev
+ * @dev: the virtio device
+ * @data: must be null
  *
  * This function unregisters an existing virtio device.
  */
-void rproc_remove_virtio_dev(struct rproc_vdev *rvdev)
+int rproc_remove_virtio_dev(struct device *dev, void *data)
 {
-       unregister_virtio_device(&rvdev->vdev);
+       struct virtio_device *vdev = dev_to_virtio(dev);
+
+       unregister_virtio_device(vdev);
+       return 0;
 }
index aacef0ea3b902c62984ff468b214eae607906431..51049d17b1e5c01b5ef94d18a27b4e5555c4d131 100644 (file)
@@ -19,6 +19,7 @@
 #include <linux/mfd/syscon.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/of_reserved_mem.h>
 #include <linux/platform_device.h>
@@ -91,6 +92,77 @@ static void st_rproc_kick(struct rproc *rproc, int vqid)
                dev_err(dev, "failed to send message via mbox: %d\n", ret);
 }
 
+static int st_rproc_mem_alloc(struct rproc *rproc,
+                             struct rproc_mem_entry *mem)
+{
+       struct device *dev = rproc->dev.parent;
+       void *va;
+
+       va = ioremap_wc(mem->dma, mem->len);
+       if (!va) {
+               dev_err(dev, "Unable to map memory region: %pa+%zx\n",
+                       &mem->dma, mem->len);
+               return -ENOMEM;
+       }
+
+       /* Update memory entry va */
+       mem->va = va;
+
+       return 0;
+}
+
+static int st_rproc_mem_release(struct rproc *rproc,
+                               struct rproc_mem_entry *mem)
+{
+       iounmap(mem->va);
+
+       return 0;
+}
+
+static int st_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
+{
+       struct device *dev = rproc->dev.parent;
+       struct device_node *np = dev->of_node;
+       struct rproc_mem_entry *mem;
+       struct reserved_mem *rmem;
+       struct of_phandle_iterator it;
+       int index = 0;
+
+       of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
+       while (of_phandle_iterator_next(&it) == 0) {
+               rmem = of_reserved_mem_lookup(it.node);
+               if (!rmem) {
+                       dev_err(dev, "unable to acquire memory-region\n");
+                       return -EINVAL;
+               }
+
+               /*  No need to map vdev buffer */
+               if (strcmp(it.node->name, "vdev0buffer")) {
+                       /* Register memory region */
+                       mem = rproc_mem_entry_init(dev, NULL,
+                                                  (dma_addr_t)rmem->base,
+                                                  rmem->size, rmem->base,
+                                                  st_rproc_mem_alloc,
+                                                  st_rproc_mem_release,
+                                                  it.node->name);
+               } else {
+                       /* Register reserved memory for vdev buffer allocation */
+                       mem = rproc_of_resm_mem_entry_init(dev, index,
+                                                          rmem->size,
+                                                          rmem->base,
+                                                          it.node->name);
+               }
+
+               if (!mem)
+                       return -ENOMEM;
+
+               rproc_add_carveout(rproc, mem);
+               index++;
+       }
+
+       return rproc_elf_load_rsc_table(rproc, fw);
+}
+
 static int st_rproc_start(struct rproc *rproc)
 {
        struct st_rproc *ddata = rproc->priv;
@@ -158,9 +230,14 @@ static int st_rproc_stop(struct rproc *rproc)
 }
 
 static const struct rproc_ops st_rproc_ops = {
-       .kick           = st_rproc_kick,
-       .start          = st_rproc_start,
-       .stop           = st_rproc_stop,
+       .kick                   = st_rproc_kick,
+       .start                  = st_rproc_start,
+       .stop                   = st_rproc_stop,
+       .parse_fw               = st_rproc_parse_fw,
+       .load                   = rproc_elf_load_segments,
+       .find_loaded_rsc_table  = rproc_elf_find_loaded_rsc_table,
+       .sanity_check           = rproc_elf_sanity_check,
+       .get_boot_addr          = rproc_elf_get_boot_addr,
 };
 
 /*
@@ -254,12 +331,6 @@ static int st_rproc_parse_dt(struct platform_device *pdev)
                return -EINVAL;
        }
 
-       err = of_reserved_mem_device_init(dev);
-       if (err) {
-               dev_err(dev, "Failed to obtain shared memory\n");
-               return err;
-       }
-
        err = clk_prepare(ddata->clk);
        if (err)
                dev_err(dev, "failed to get clock\n");
@@ -387,8 +458,6 @@ static int st_rproc_remove(struct platform_device *pdev)
 
        clk_disable_unprepare(ddata->clk);
 
-       of_reserved_mem_device_release(&pdev->dev);
-
        for (i = 0; i < ST_RPROC_MAX_VRING * MBOX_MAX; i++)
                mbox_free_channel(ddata->mbox_chan[i]);
 
index 664f957012cdee0247484fed2e157a30b7ec1fc9..5d3685bd76a2d82f5a25df2928203306e17ee526 100644 (file)
 
 #define pr_fmt(fmt) "%s: " fmt, __func__
 
+#include <linux/dma-mapping.h>
+#include <linux/idr.h>
+#include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/virtio.h>
-#include <linux/virtio_ids.h>
-#include <linux/virtio_config.h>
+#include <linux/mutex.h>
+#include <linux/of_device.h>
+#include <linux/rpmsg.h>
 #include <linux/scatterlist.h>
-#include <linux/dma-mapping.h>
 #include <linux/slab.h>
-#include <linux/idr.h>
-#include <linux/jiffies.h>
 #include <linux/sched.h>
+#include <linux/virtio.h>
+#include <linux/virtio_ids.h>
+#include <linux/virtio_config.h>
 #include <linux/wait.h>
-#include <linux/rpmsg.h>
-#include <linux/mutex.h>
-#include <linux/of_device.h>
 
 #include "rpmsg_internal.h"
 
@@ -912,7 +912,7 @@ static int rpmsg_probe(struct virtio_device *vdev)
        total_buf_space = vrp->num_bufs * vrp->buf_size;
 
        /* allocate coherent memory for the buffers */
-       bufs_va = dma_alloc_coherent(vdev->dev.parent->parent,
+       bufs_va = dma_alloc_coherent(vdev->dev.parent,
                                     total_buf_space, &vrp->bufs_dma,
                                     GFP_KERNEL);
        if (!bufs_va) {
@@ -980,7 +980,7 @@ static int rpmsg_probe(struct virtio_device *vdev)
        return 0;
 
 free_coherent:
-       dma_free_coherent(vdev->dev.parent->parent, total_buf_space,
+       dma_free_coherent(vdev->dev.parent, total_buf_space,
                          bufs_va, vrp->bufs_dma);
 vqs_del:
        vdev->config->del_vqs(vrp->vdev);
@@ -1015,7 +1015,7 @@ static void rpmsg_remove(struct virtio_device *vdev)
 
        vdev->config->del_vqs(vrp->vdev);
 
-       dma_free_coherent(vdev->dev.parent->parent, total_buf_space,
+       dma_free_coherent(vdev->dev.parent, total_buf_space,
                          vrp->rbufs, vrp->bufs_dma);
 
        kfree(vrp);
index 507a2b5242085f458da932f955020f9a53567267..04d04709f2bda8d5edf65cbdf8ca56ee7fc00ac5 100644 (file)
@@ -345,9 +345,9 @@ struct firmware;
  * @stop:      power off the device
  * @kick:      kick a virtqueue (virtqueue id given as a parameter)
  * @da_to_va:  optional platform hook to perform address translations
- * @load_rsc_table:    load resource table from firmware image
+ * @parse_fw:  parse firmware to extract information (e.g. resource table)
  * @find_loaded_rsc_table: find the loaded resouce table
- * @load:              load firmeware to memory, where the remote processor
+ * @load:              load firmware to memory, where the remote processor
  *                     expects to find it
  * @sanity_check:      sanity check the fw image
  * @get_boot_addr:     get boot address to entry point specified in firmware
@@ -554,11 +554,11 @@ struct rproc_vdev {
        struct kref refcount;
 
        struct rproc_subdev subdev;
+       struct device dev;
 
        unsigned int id;
        struct list_head node;
        struct rproc *rproc;
-       struct virtio_device vdev;
        struct rproc_vring vring[RVDEV_NUM_VRINGS];
        u32 rsc_offset;
        u32 index;
@@ -601,7 +601,7 @@ int rproc_coredump_add_custom_segment(struct rproc *rproc,
 
 static inline struct rproc_vdev *vdev_to_rvdev(struct virtio_device *vdev)
 {
-       return container_of(vdev, struct rproc_vdev, vdev);
+       return container_of(vdev->dev.parent, struct rproc_vdev, dev);
 }
 
 static inline struct rproc *vdev_to_rproc(struct virtio_device *vdev)