Merge tag 'rproc-v4.15' of git://github.com/andersson/remoteproc
authorLinus Torvalds <torvalds@linux-foundation.org>
Sat, 18 Nov 2017 04:14:10 +0000 (20:14 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sat, 18 Nov 2017 04:14:10 +0000 (20:14 -0800)
Pull remoteproc updates from Bjorn Andersson:
 "This adds an interface for configuring Qualcomm's "secure SMMU" and
  adds support for booting the modem Hexagon on MSM8996.

  Two new debugfs entries are added in the remoteproc core to introspect
  the list of memory carveouts and the loaded resource table"

* tag 'rproc-v4.15' of git://github.com/andersson/remoteproc:
  remoteproc: qcom: Fix error handling paths in order to avoid memory leaks
  remoteproc: qcom: Drop pr_err in q6v5_xfer_mem_ownership()
  remoteproc: debug: add carveouts list dump feature
  remoteproc: debug: add resource table dump feature
  remoteproc: qcom: Add support for mss remoteproc on msm8996
  remoteproc: qcom: Make secure world call for mem ownership switch
  remoteproc: qcom: refactor mss fw image loading sequence
  firmware: scm: Add new SCM call API for switching memory ownership

1  2 
drivers/firmware/qcom_scm-32.c
drivers/firmware/qcom_scm-64.c
drivers/firmware/qcom_scm.c
drivers/firmware/qcom_scm.h
include/linux/qcom_scm.h

index 68b2033bc30e2bd3425e395462faf5d1bfc50670,60d96bcf6694708978039e9edee10dcd1273b4be..dfbd894d5bb712d0df01fc37cc99dc199e095de0
@@@ -561,12 -561,6 +561,12 @@@ int __qcom_scm_pas_mss_reset(struct dev
        return ret ? : le32_to_cpu(out);
  }
  
 +int __qcom_scm_set_dload_mode(struct device *dev, bool enable)
 +{
 +      return qcom_scm_call_atomic2(QCOM_SCM_SVC_BOOT, QCOM_SCM_SET_DLOAD_MODE,
 +                                   enable ? QCOM_SCM_SET_DLOAD_MODE : 0, 0);
 +}
 +
  int __qcom_scm_set_remote_state(struct device *dev, u32 state, u32 id)
  {
        struct {
        return ret ? : le32_to_cpu(scm_ret);
  }
  
+ 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)
+ {
+       return -ENODEV;
+ }
  int __qcom_scm_restore_sec_cfg(struct device *dev, u32 device_id,
                               u32 spare)
  {
@@@ -602,21 -603,3 +609,21 @@@ int __qcom_scm_iommu_secure_ptbl_init(s
  {
        return -ENODEV;
  }
 +
 +int __qcom_scm_io_readl(struct device *dev, phys_addr_t addr,
 +                      unsigned int *val)
 +{
 +      int ret;
 +
 +      ret = qcom_scm_call_atomic1(QCOM_SCM_SVC_IO, QCOM_SCM_IO_READ, addr);
 +      if (ret >= 0)
 +              *val = ret;
 +
 +      return ret < 0 ? ret : 0;
 +}
 +
 +int __qcom_scm_io_writel(struct device *dev, phys_addr_t addr, unsigned int val)
 +{
 +      return qcom_scm_call_atomic2(QCOM_SCM_SVC_IO, QCOM_SCM_IO_WRITE,
 +                                   addr, val);
 +}
index 3fea6f563ca91f17b380f2a5a138900ddfc0c141,ea5b1e680f677e7ba967ce86a83868b8bf218c1f..688525dd4aee599548c52502168b3f04f62388fb
@@@ -382,6 -382,33 +382,33 @@@ int __qcom_scm_set_remote_state(struct 
        return ret ? : res.a1;
  }
  
+ 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 = {0};
+       struct arm_smccc_res res;
+       desc.args[0] = mem_region;
+       desc.args[1] = mem_sz;
+       desc.args[2] = src;
+       desc.args[3] = src_sz;
+       desc.args[4] = dest;
+       desc.args[5] = dest_sz;
+       desc.args[6] = 0;
+       desc.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);
+       ret = qcom_scm_call(dev, QCOM_SCM_SVC_MP,
+                           QCOM_MEM_PROT_ASSIGN_ID,
+                           &desc, &res);
+       return ret ? : res.a1;
+ }
  int __qcom_scm_restore_sec_cfg(struct device *dev, u32 device_id, u32 spare)
  {
        struct qcom_scm_desc desc = {0};
@@@ -439,47 -466,3 +466,47 @@@ int __qcom_scm_iommu_secure_ptbl_init(s
  
        return ret;
  }
 +
 +int __qcom_scm_set_dload_mode(struct device *dev, bool enable)
 +{
 +      struct qcom_scm_desc desc = {0};
 +      struct arm_smccc_res res;
 +
 +      desc.args[0] = QCOM_SCM_SET_DLOAD_MODE;
 +      desc.args[1] = enable ? QCOM_SCM_SET_DLOAD_MODE : 0;
 +      desc.arginfo = QCOM_SCM_ARGS(2);
 +
 +      return qcom_scm_call(dev, QCOM_SCM_SVC_BOOT, QCOM_SCM_SET_DLOAD_MODE,
 +                           &desc, &res);
 +}
 +
 +int __qcom_scm_io_readl(struct device *dev, phys_addr_t addr,
 +                      unsigned int *val)
 +{
 +      struct qcom_scm_desc desc = {0};
 +      struct arm_smccc_res res;
 +      int ret;
 +
 +      desc.args[0] = addr;
 +      desc.arginfo = QCOM_SCM_ARGS(1);
 +
 +      ret = qcom_scm_call(dev, QCOM_SCM_SVC_IO, QCOM_SCM_IO_READ,
 +                          &desc, &res);
 +      if (ret >= 0)
 +              *val = res.a1;
 +
 +      return ret < 0 ? ret : 0;
 +}
 +
 +int __qcom_scm_io_writel(struct device *dev, phys_addr_t addr, unsigned int val)
 +{
 +      struct qcom_scm_desc desc = {0};
 +      struct arm_smccc_res res;
 +
 +      desc.args[0] = addr;
 +      desc.args[1] = val;
 +      desc.arginfo = QCOM_SCM_ARGS(2);
 +
 +      return qcom_scm_call(dev, QCOM_SCM_SVC_IO, QCOM_SCM_IO_WRITE,
 +                           &desc, &res);
 +}
index 9064e559a01f5050737de43d49df4f94df01b5a2,334eaa341828538334a45519d6721984914a77a7..af4c75217ea6647955ff28585b1e512b20eb258f
  #include <linux/cpumask.h>
  #include <linux/export.h>
  #include <linux/dma-mapping.h>
 +#include <linux/module.h>
  #include <linux/types.h>
  #include <linux/qcom_scm.h>
  #include <linux/of.h>
 +#include <linux/of_address.h>
  #include <linux/of_platform.h>
  #include <linux/clk.h>
  #include <linux/reset-controller.h>
  
  #include "qcom_scm.h"
  
 +static bool download_mode = IS_ENABLED(CONFIG_QCOM_SCM_DOWNLOAD_MODE_DEFAULT);
 +module_param(download_mode, bool, 0);
 +
  #define SCM_HAS_CORE_CLK      BIT(0)
  #define SCM_HAS_IFACE_CLK     BIT(1)
  #define SCM_HAS_BUS_CLK               BIT(2)
@@@ -43,10 -38,21 +43,23 @@@ struct qcom_scm 
        struct clk *iface_clk;
        struct clk *bus_clk;
        struct reset_controller_dev reset;
 +
 +      u64 dload_mode_addr;
  };
  
+ struct qcom_scm_current_perm_info {
+       __le32 vmid;
+       __le32 perm;
+       __le64 ctx;
+       __le32 ctx_size;
+       __le32 unused;
+ };
+ struct qcom_scm_mem_map_info {
+       __le64 mem_addr;
+       __le64 mem_size;
+ };
  static struct qcom_scm *__scm;
  
  static int qcom_scm_clk_enable(void)
@@@ -340,66 -346,6 +353,66 @@@ int qcom_scm_iommu_secure_ptbl_init(u6
  }
  EXPORT_SYMBOL(qcom_scm_iommu_secure_ptbl_init);
  
 +int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val)
 +{
 +      return __qcom_scm_io_readl(__scm->dev, addr, val);
 +}
 +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);
 +}
 +EXPORT_SYMBOL(qcom_scm_io_writel);
 +
 +static void qcom_scm_set_download_mode(bool enable)
 +{
 +      bool avail;
 +      int ret = 0;
 +
 +      avail = __qcom_scm_is_call_available(__scm->dev,
 +                                           QCOM_SCM_SVC_BOOT,
 +                                           QCOM_SCM_SET_DLOAD_MODE);
 +      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_SET_DLOAD_MODE : 0);
 +      } else {
 +              dev_err(__scm->dev,
 +                      "No available mechanism for setting download mode\n");
 +      }
 +
 +      if (ret)
 +              dev_err(__scm->dev, "failed to set download mode: %d\n", ret);
 +}
 +
 +static int qcom_scm_find_dload_address(struct device *dev, u64 *addr)
 +{
 +      struct device_node *tcsr;
 +      struct device_node *np = dev->of_node;
 +      struct resource res;
 +      u32 offset;
 +      int ret;
 +
 +      tcsr = of_parse_phandle(np, "qcom,dload-mode", 0);
 +      if (!tcsr)
 +              return 0;
 +
 +      ret = of_address_to_resource(tcsr, 0, &res);
 +      of_node_put(tcsr);
 +      if (ret)
 +              return ret;
 +
 +      ret = of_property_read_u32_index(np, "qcom,dload-mode", 1, &offset);
 +      if (ret < 0)
 +              return ret;
 +
 +      *addr = res.start + offset;
 +
 +      return 0;
 +}
 +
  /**
   * qcom_scm_is_available() - Checks if SCM is available
   */
@@@ -415,6 -361,88 +428,88 @@@ int qcom_scm_set_remote_state(u32 state
  }
  EXPORT_SYMBOL(qcom_scm_set_remote_state);
  
+ /**
+  * qcom_scm_assign_mem() - Make a secure call to reassign memory ownership
+  * @mem_addr: mem region whose ownership need to be reassigned
+  * @mem_sz:   size of the region.
+  * @srcvm:    vmid for current set of owners, each set bit in
+  *            flag indicate a unique owner
+  * @newvm:    array having new owners and corrsponding permission
+  *            flags
+  * @dest_cnt: number of owners in next set.
+  *
+  * Return negative errno on failure, 0 on success, with @srcvm updated.
+  */
+ int qcom_scm_assign_mem(phys_addr_t mem_addr, size_t mem_sz,
+                       unsigned int *srcvm,
+                       struct qcom_scm_vmperm *newvm, int dest_cnt)
+ {
+       struct qcom_scm_current_perm_info *destvm;
+       struct qcom_scm_mem_map_info *mem_to_map;
+       phys_addr_t mem_to_map_phys;
+       phys_addr_t dest_phys;
+       phys_addr_t ptr_phys;
+       size_t mem_to_map_sz;
+       size_t dest_sz;
+       size_t src_sz;
+       size_t ptr_sz;
+       int next_vm;
+       __le32 *src;
+       void *ptr;
+       int ret;
+       int len;
+       int i;
+       src_sz = hweight_long(*srcvm) * sizeof(*src);
+       mem_to_map_sz = sizeof(*mem_to_map);
+       dest_sz = dest_cnt * sizeof(*destvm);
+       ptr_sz = ALIGN(src_sz, SZ_64) + ALIGN(mem_to_map_sz, SZ_64) +
+                       ALIGN(dest_sz, SZ_64);
+       ptr = dma_alloc_coherent(__scm->dev, ptr_sz, &ptr_phys, GFP_KERNEL);
+       if (!ptr)
+               return -ENOMEM;
+       /* Fill source vmid detail */
+       src = ptr;
+       len = hweight_long(*srcvm);
+       for (i = 0; i < len; i++) {
+               src[i] = cpu_to_le32(ffs(*srcvm) - 1);
+               *srcvm ^= 1 << (ffs(*srcvm) - 1);
+       }
+       /* Fill details of mem buff to map */
+       mem_to_map = ptr + ALIGN(src_sz, SZ_64);
+       mem_to_map_phys = ptr_phys + ALIGN(src_sz, SZ_64);
+       mem_to_map[0].mem_addr = cpu_to_le64(mem_addr);
+       mem_to_map[0].mem_size = cpu_to_le64(mem_sz);
+       next_vm = 0;
+       /* Fill details of next vmid detail */
+       destvm = ptr + ALIGN(mem_to_map_sz, SZ_64) + ALIGN(src_sz, SZ_64);
+       dest_phys = ptr_phys + ALIGN(mem_to_map_sz, SZ_64) + ALIGN(src_sz, SZ_64);
+       for (i = 0; i < dest_cnt; i++) {
+               destvm[i].vmid = cpu_to_le32(newvm[i].vmid);
+               destvm[i].perm = cpu_to_le32(newvm[i].perm);
+               destvm[i].ctx = 0;
+               destvm[i].ctx_size = 0;
+               next_vm |= BIT(newvm[i].vmid);
+       }
+       ret = __qcom_scm_assign_mem(__scm->dev, mem_to_map_phys, mem_to_map_sz,
+                                   ptr_phys, src_sz, dest_phys, dest_sz);
+       dma_free_coherent(__scm->dev, ALIGN(ptr_sz, SZ_64), ptr, ptr_phys);
+       if (ret) {
+               dev_err(__scm->dev,
+                       "Assign memory protection call failed %d.\n", ret);
+               return -EINVAL;
+       }
+       *srcvm = next_vm;
+       return 0;
+ }
+ EXPORT_SYMBOL(qcom_scm_assign_mem);
  static int qcom_scm_probe(struct platform_device *pdev)
  {
        struct qcom_scm *scm;
        if (!scm)
                return -ENOMEM;
  
 +      ret = qcom_scm_find_dload_address(&pdev->dev, &scm->dload_mode_addr);
 +      if (ret < 0)
 +              return ret;
 +
        clks = (unsigned long)of_device_get_match_data(&pdev->dev);
        if (clks & SCM_HAS_CORE_CLK) {
                scm->core_clk = devm_clk_get(&pdev->dev, "core");
  
        __qcom_scm_init();
  
 +      /*
 +       * If requested enable "download mode", from this point on warmboot
 +       * will cause the the boot stages to enter download mode, unless
 +       * disabled below by a clean shutdown/reboot.
 +       */
 +      if (download_mode)
 +              qcom_scm_set_download_mode(true);
 +
        return 0;
  }
  
 +static void qcom_scm_shutdown(struct platform_device *pdev)
 +{
 +      /* Clean shutdown, disable download mode to allow normal restart */
 +      if (download_mode)
 +              qcom_scm_set_download_mode(false);
 +}
 +
  static const struct of_device_id qcom_scm_dt_match[] = {
        { .compatible = "qcom,scm-apq8064",
          /* FIXME: This should have .data = (void *) SCM_HAS_CORE_CLK */
@@@ -522,7 -531,6 +617,7 @@@ static struct platform_driver qcom_scm_
                .of_match_table = qcom_scm_dt_match,
        },
        .probe = qcom_scm_probe,
 +      .shutdown = qcom_scm_shutdown,
  };
  
  static int __init qcom_scm_init(void)
index 83f171c239430312169596054682c10043c9651f,fe54b7ba4db4b980e5f00aa6aeb224a0dd685321..dcd7f7917fc71a5547f87577682cbca2ec3da078
  
  #define QCOM_SCM_SVC_BOOT             0x1
  #define QCOM_SCM_BOOT_ADDR            0x1
 +#define QCOM_SCM_SET_DLOAD_MODE               0x10
  #define QCOM_SCM_BOOT_ADDR_MC         0x11
  #define QCOM_SCM_SET_REMOTE_STATE     0xa
  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_FLAG_HLOS            0x01
  #define QCOM_SCM_FLAG_COLDBOOT_MC     0x02
@@@ -32,12 -30,6 +32,12 @@@ extern int __qcom_scm_set_cold_boot_add
  #define QCOM_SCM_CMD_CORE_HOTPLUGGED  0x10
  extern void __qcom_scm_cpu_power_down(u32 flags);
  
 +#define QCOM_SCM_SVC_IO                       0x5
 +#define QCOM_SCM_IO_READ              0x1
 +#define QCOM_SCM_IO_WRITE             0x2
 +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             0x6
  #define QCOM_IS_CALL_AVAIL_CMD                0x1
  extern int __qcom_scm_is_call_available(struct device *dev, u32 svc_id,
@@@ -103,5 -95,10 +103,10 @@@ extern int __qcom_scm_iommu_secure_ptbl
                                             size_t *size);
  extern int __qcom_scm_iommu_secure_ptbl_init(struct device *dev, u64 addr,
                                             u32 size, u32 spare);
+ #define QCOM_MEM_PROT_ASSIGN_ID       0x16
+ 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);
  
  #endif
diff --combined include/linux/qcom_scm.h
index e8357f57069592b28f730bd2f6d65a8fb3e621d5,6f8da9e182f9fdd9ff8a0e662d4ab3a0efc67173..1fd27d68926bc8e6e6565bf72523ef295c614dbe
@@@ -23,6 -23,19 +23,19 @@@ struct qcom_scm_hdcp_req 
        u32 val;
  };
  
+ struct qcom_scm_vmperm {
+       int vmid;
+       int perm;
+ };
+ #define QCOM_SCM_VMID_HLOS       0x3
+ #define QCOM_SCM_VMID_MSS_MSA    0xF
+ #define QCOM_SCM_PERM_READ       0x4
+ #define QCOM_SCM_PERM_WRITE      0x2
+ #define QCOM_SCM_PERM_EXEC       0x1
+ #define QCOM_SCM_PERM_RW (QCOM_SCM_PERM_READ | QCOM_SCM_PERM_WRITE)
+ #define QCOM_SCM_PERM_RWX (QCOM_SCM_PERM_RW | QCOM_SCM_PERM_EXEC)
  #if IS_ENABLED(CONFIG_QCOM_SCM)
  extern int qcom_scm_set_cold_boot_addr(void *entry, const cpumask_t *cpus);
  extern int qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus);
@@@ -37,14 -50,15 +50,17 @@@ extern int qcom_scm_pas_mem_setup(u32 p
                                  phys_addr_t size);
  extern int qcom_scm_pas_auth_and_reset(u32 peripheral);
  extern int qcom_scm_pas_shutdown(u32 peripheral);
+ extern int qcom_scm_assign_mem(phys_addr_t mem_addr, size_t mem_sz,
+                              unsigned int *src, struct qcom_scm_vmperm *newvm,
+                              int dest_cnt);
  extern void qcom_scm_cpu_power_down(u32 flags);
  extern u32 qcom_scm_get_version(void);
  extern int qcom_scm_set_remote_state(u32 state, u32 id);
  extern int qcom_scm_restore_sec_cfg(u32 device_id, u32 spare);
  extern int qcom_scm_iommu_secure_ptbl_size(u32 spare, size_t *size);
  extern int qcom_scm_iommu_secure_ptbl_init(u64 addr, u32 size, u32 spare);
 +extern int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val);
 +extern int qcom_scm_io_writel(phys_addr_t addr, unsigned int val);
  #else
  static inline
  int qcom_scm_set_cold_boot_addr(void *entry, const cpumask_t *cpus)
@@@ -75,7 -89,5 +91,7 @@@ qcom_scm_set_remote_state(u32 state,u3
  static inline int qcom_scm_restore_sec_cfg(u32 device_id, u32 spare) { return -ENODEV; }
  static inline int qcom_scm_iommu_secure_ptbl_size(u32 spare, size_t *size) { return -ENODEV; }
  static inline int qcom_scm_iommu_secure_ptbl_init(u64 addr, u32 size, u32 spare) { return -ENODEV; }
 +static inline int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val) { return -ENODEV; }
 +static inline int qcom_scm_io_writel(phys_addr_t addr, unsigned int val) { return -ENODEV; }
  #endif
  #endif