[07/15] soc: qcom: smem: adjust for U-Boot

Port over the smem code to U-Boot and remove socinfo.

Signed-off-by: Caleb Connolly <caleb.connolly@linaro.org>
---
 drivers/soc/qcom/smem.c | 320 +++++++++---------------------------------------
 include/soc/qcom/smem.h |   9 +-
 2 files changed, 63 insertions(+), 266 deletions(-)

Hi Caleb,

On Sun, 24 Nov 2024 at 12:17, Caleb Connolly <caleb.connolly@linaro.org> wrote:
>
> Port over the smem code to U-Boot and remove socinfo.
>
> Signed-off-by: Caleb Connolly <caleb.connolly@linaro.org>
> ---
>  drivers/soc/qcom/smem.c | 320 +++++++++---------------------------------------
>  include/soc/qcom/smem.h |   9 +-
>  2 files changed, 63 insertions(+), 266 deletions(-)

Reviewed-by: Simon Glass <sjg@chromium.org>

I'd really rather have static inlines for the semaphores and locks,
rather than changing the code. This is changing more a quarter of the
code in the C file. Can you take a look?

Also note that in U-Boot, header files need comments. Is that
permitted in Linux?

Regards,
Simon


>
> diff --git a/drivers/soc/qcom/smem.c b/drivers/soc/qcom/smem.c
> index 7143856e85c3..5166f289dfb6 100644
> --- a/drivers/soc/qcom/smem.c
> +++ b/drivers/soc/qcom/smem.c
> @@ -3,17 +3,18 @@
>   * Copyright (c) 2015, Sony Mobile Communications AB.
>   * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
>   */
>
> +#define pr_fmt(fmt) "smem: " fmt
> +
>  #include <dm/device.h>
>  #include <dm/device_compat.h>
>  #include <dm/ofnode.h>
>  #include <linux/bug.h>
>  #include <linux/io.h>
>  #include <linux/ioport.h>
>  #include <linux/sizes.h>
>  #include <soc/qcom/smem.h>
> -#include <soc/qcom/socinfo.h>
>
>  /*
>   * The Qualcomm shared memory system is a allocate only heap structure that
>   * consists of one of more memory areas that can be accessed by the processors
> @@ -260,31 +261,23 @@ struct smem_region {
>  };
>
>  /**
>   * struct qcom_smem - device data for the smem device
> - * @dev:       device pointer
> - * @hwlock:    reference to a hwspinlock
>   * @ptable: virtual base of partition table
>   * @global_partition: describes for global partition when in use
>   * @partitions: list of partitions of current processor/host
>   * @item_count: max accepted item number
> - * @socinfo:   platform device pointer
>   * @num_regions: number of @regions
>   * @regions:   list of the memory regions defining the shared memory
>   */
>  struct qcom_smem {
> -       struct device *dev;
> -
> -       struct hwspinlock *hwlock;
> -
>         u32 item_count;
> -       struct platform_device *socinfo;
>         struct smem_ptable *ptable;
>         struct smem_partition global_partition;
>         struct smem_partition partitions[SMEM_HOST_COUNT];
>
>         unsigned num_regions;
> -       struct smem_region regions[] __counted_by(num_regions);
> +       struct smem_region regions[];
>  };
>
>  static void *
>  phdr_to_last_uncached_entry(struct smem_partition_header *phdr)
> @@ -351,38 +344,9 @@ static void *cached_entry_to_item(struct smem_private_entry *e)
>         return p - le32_to_cpu(e->size);
>  }
>
>  /* Pointer to the one and only smem handle */
> -static struct qcom_smem *__smem;
> -
> -/* Timeout (ms) for the trylock of remote spinlocks */
> -#define HWSPINLOCK_TIMEOUT     1000
> -
> -/* The qcom hwspinlock id is always plus one from the smem host id */
> -#define SMEM_HOST_ID_TO_HWSPINLOCK_ID(__x) ((__x) + 1)
> -
> -/**
> - * qcom_smem_bust_hwspin_lock_by_host() - bust the smem hwspinlock for a host
> - * @host:      remote processor id
> - *
> - * Busts the hwspin_lock for the given smem host id. This helper is intended
> - * for remoteproc drivers that manage remoteprocs with an equivalent smem
> - * driver instance in the remote firmware. Drivers can force a release of the
> - * smem hwspin_lock if the rproc unexpectedly goes into a bad state.
> - *
> - * Context: Process context.
> - *
> - * Returns: 0 on success, otherwise negative errno.
> - */
> -int qcom_smem_bust_hwspin_lock_by_host(unsigned int host)
> -{
> -       /* This function is for remote procs, so ignore SMEM_HOST_APPS */
> -       if (host == SMEM_HOST_APPS || host >= SMEM_HOST_COUNT)
> -               return -EINVAL;
> -
> -       return hwspin_lock_bust(__smem->hwlock, SMEM_HOST_ID_TO_HWSPINLOCK_ID(host));
> -}
> -EXPORT_SYMBOL_GPL(qcom_smem_bust_hwspin_lock_by_host);
> +static struct qcom_smem *__smem __section(".data") = NULL;
>
>  /**
>   * qcom_smem_is_available() - Check if SMEM is available
>   *
> @@ -429,9 +393,9 @@ static int qcom_smem_alloc_private(struct qcom_smem *smem,
>
>         /* Check that we don't grow into the cached region */
>         alloc_size = sizeof(*hdr) + ALIGN(size, 8);
>         if ((void *)hdr + alloc_size > cached) {
> -               dev_err(smem->dev, "Out of memory\n");
> +               log_err("Out of memory\n");
>                 return -ENOSPC;
>         }
>
>         hdr->canary = SMEM_PRIVATE_CANARY;
> @@ -449,9 +413,9 @@ static int qcom_smem_alloc_private(struct qcom_smem *smem,
>         le32_add_cpu(&phdr->offset_free_uncached, alloc_size);
>
>         return 0;
>  bad_canary:
> -       dev_err(smem->dev, "Found invalid canary in hosts %hu:%hu partition\n",
> +       log_err("Found invalid canary in hosts %hu:%hu partition\n",
>                 le16_to_cpu(phdr->host0), le16_to_cpu(phdr->host1));
>
>         return -EINVAL;
>  }
> @@ -500,29 +464,21 @@ static int qcom_smem_alloc_global(struct qcom_smem *smem,
>   */
>  int qcom_smem_alloc(unsigned host, unsigned item, size_t size)
>  {
>         struct smem_partition *part;
> -       unsigned long flags;
>         int ret;
>
>         if (!__smem)
>                 return -EPROBE_DEFER;
>
>         if (item < SMEM_ITEM_LAST_FIXED) {
> -               dev_err(__smem->dev,
> -                       "Rejecting allocation of static entry %d\n", item);
> +               log_err("Rejecting allocation of static entry %d\n", item);
>                 return -EINVAL;
>         }
>
>         if (WARN_ON(item >= __smem->item_count))
>                 return -EINVAL;
>
> -       ret = hwspin_lock_timeout_irqsave(__smem->hwlock,
> -                                         HWSPINLOCK_TIMEOUT,
> -                                         &flags);
> -       if (ret)
> -               return ret;
> -
>         if (host < SMEM_HOST_COUNT && __smem->partitions[host].virt_base) {
>                 part = &__smem->partitions[host];
>                 ret = qcom_smem_alloc_private(__smem, part, item, size);
>         } else if (__smem->global_partition.virt_base) {
> @@ -531,10 +487,8 @@ int qcom_smem_alloc(unsigned host, unsigned item, size_t size)
>         } else {
>                 ret = qcom_smem_alloc_global(__smem, item, size);
>         }
>
> -       hwspin_unlock_irqrestore(__smem->hwlock, &flags);
> -
>         return ret;
>  }
>  EXPORT_SYMBOL_GPL(qcom_smem_alloc);
>
> @@ -660,9 +614,9 @@ static void *qcom_smem_get_private(struct qcom_smem *smem,
>
>         return ERR_PTR(-ENOENT);
>
>  invalid_canary:
> -       dev_err(smem->dev, "Found invalid canary in hosts %hu:%hu partition\n",
> +       log_err("Found invalid canary in hosts %hu:%hu partition\n",
>                         le16_to_cpu(phdr->host0), le16_to_cpu(phdr->host1));
>
>         return ERR_PTR(-EINVAL);
>  }
> @@ -796,63 +750,8 @@ phys_addr_t qcom_smem_virt_to_phys(void *p)
>         return 0;
>  }
>  EXPORT_SYMBOL_GPL(qcom_smem_virt_to_phys);
>
> -/**
> - * qcom_smem_get_soc_id() - return the SoC ID
> - * @id:        On success, we return the SoC ID here.
> - *
> - * Look up SoC ID from HW/SW build ID and return it.
> - *
> - * Return: 0 on success, negative errno on failure.
> - */
> -int qcom_smem_get_soc_id(u32 *id)
> -{
> -       struct socinfo *info;
> -
> -       info = qcom_smem_get(QCOM_SMEM_HOST_ANY, SMEM_HW_SW_BUILD_ID, NULL);
> -       if (IS_ERR(info))
> -               return PTR_ERR(info);
> -
> -       *id = __le32_to_cpu(info->id);
> -
> -       return 0;
> -}
> -EXPORT_SYMBOL_GPL(qcom_smem_get_soc_id);
> -
> -/**
> - * qcom_smem_get_feature_code() - return the feature code
> - * @code: On success, return the feature code here.
> - *
> - * Look up the feature code identifier from SMEM and return it.
> - *
> - * Return: 0 on success, negative errno on failure.
> - */
> -int qcom_smem_get_feature_code(u32 *code)
> -{
> -       struct socinfo *info;
> -       u32 raw_code;
> -
> -       info = qcom_smem_get(QCOM_SMEM_HOST_ANY, SMEM_HW_SW_BUILD_ID, NULL);
> -       if (IS_ERR(info))
> -               return PTR_ERR(info);
> -
> -       /* This only makes sense for socinfo >= 16 */
> -       if (__le32_to_cpu(info->fmt) < SOCINFO_VERSION(0, 16))
> -               return -EOPNOTSUPP;
> -
> -       raw_code = __le32_to_cpu(info->feature_code);
> -
> -       /* Ensure the value makes sense */
> -       if (raw_code > SOCINFO_FC_INT_MAX)
> -               raw_code = SOCINFO_FC_UNKNOWN;
> -
> -       *code = raw_code;
> -
> -       return 0;
> -}
> -EXPORT_SYMBOL_GPL(qcom_smem_get_feature_code);
> -
>  static int qcom_smem_get_sbl_version(struct qcom_smem *smem)
>  {
>         struct smem_header *header;
>         __le32 *versions;
> @@ -873,10 +772,9 @@ static struct smem_ptable *qcom_smem_get_ptable(struct qcom_smem *smem)
>                 return ERR_PTR(-ENOENT);
>
>         version = le32_to_cpu(ptable->version);
>         if (version != 1) {
> -               dev_err(smem->dev,
> -                       "Unsupported partition header version %d\n", version);
> +               log_err("Unsupported partition header version %d\n", version);
>                 return ERR_PTR(-EINVAL);
>         }
>         return ptable;
>  }
> @@ -906,42 +804,42 @@ static struct smem_partition_header *
>  qcom_smem_partition_header(struct qcom_smem *smem,
>                 struct smem_ptable_entry *entry, u16 host0, u16 host1)
>  {
>         struct smem_partition_header *header;
> -       u32 phys_addr;
> +       u64 phys_addr;
>         u32 size;
>
>         phys_addr = smem->regions[0].aux_base + le32_to_cpu(entry->offset);
> -       header = devm_ioremap_wc(smem->dev, phys_addr, le32_to_cpu(entry->size));
> +       header = (void *)phys_addr; // devm_ioremap_wc()
>
>         if (!header)
>                 return NULL;
>
>         if (memcmp(header->magic, SMEM_PART_MAGIC, sizeof(header->magic))) {
> -               dev_err(smem->dev, "bad partition magic %4ph\n", header->magic);
> +               log_err("bad partition magic %4ph\n", header->magic);
>                 return NULL;
>         }
>
>         if (host0 != le16_to_cpu(header->host0)) {
> -               dev_err(smem->dev, "bad host0 (%hu != %hu)\n",
> -                               host0, le16_to_cpu(header->host0));
> +               log_err("bad host0 (%hu != %hu)\n",
> +                       host0, le16_to_cpu(header->host0));
>                 return NULL;
>         }
>         if (host1 != le16_to_cpu(header->host1)) {
> -               dev_err(smem->dev, "bad host1 (%hu != %hu)\n",
> -                               host1, le16_to_cpu(header->host1));
> +               log_err("bad host1 (%hu != %hu)\n",
> +                       host1, le16_to_cpu(header->host1));
>                 return NULL;
>         }
>
>         size = le32_to_cpu(header->size);
>         if (size != le32_to_cpu(entry->size)) {
> -               dev_err(smem->dev, "bad partition size (%u != %u)\n",
> +               log_err("bad partition size (%u != %u)\n",
>                         size, le32_to_cpu(entry->size));
>                 return NULL;
>         }
>
>         if (le32_to_cpu(header->offset_free_uncached) > size) {
> -               dev_err(smem->dev, "bad partition free uncached (%u > %u)\n",
> +               log_err("bad partition free uncached (%u > %u)\n",
>                         le32_to_cpu(header->offset_free_uncached), size);
>                 return NULL;
>         }
>
> @@ -956,9 +854,9 @@ static int qcom_smem_set_global_partition(struct qcom_smem *smem)
>         bool found = false;
>         int i;
>
>         if (smem->global_partition.virt_base) {
> -               dev_err(smem->dev, "Already found the global partition\n");
> +               log_err("Already found the global partition\n");
>                 return -EINVAL;
>         }
>
>         ptable = qcom_smem_get_ptable(smem);
> @@ -981,9 +879,9 @@ static int qcom_smem_set_global_partition(struct qcom_smem *smem)
>                 }
>         }
>
>         if (!found) {
> -               dev_err(smem->dev, "Missing entry for global partition\n");
> +               log_err("Missing entry for global partition\n");
>                 return -EINVAL;
>         }
>
>         header = qcom_smem_partition_header(smem, entry,
> @@ -1030,14 +928,14 @@ qcom_smem_enumerate_partitions(struct qcom_smem *smem, u16 local_host)
>                 else
>                         continue;
>
>                 if (remote_host >= SMEM_HOST_COUNT) {
> -                       dev_err(smem->dev, "bad host %u\n", remote_host);
> +                       log_err("bad host %u\n", remote_host);
>                         return -EINVAL;
>                 }
>
>                 if (smem->partitions[remote_host].virt_base) {
> -                       dev_err(smem->dev, "duplicate host %u\n", remote_host);
> +                       log_err("duplicate host %u\n", remote_host);
>                         return -EINVAL;
>                 }
>
>                 header = qcom_smem_partition_header(smem, entry, host0, host1);
> @@ -1058,12 +956,12 @@ static int qcom_smem_map_toc(struct qcom_smem *smem, struct smem_region *region)
>  {
>         u32 ptable_start;
>
>         /* map starting 4K for smem header */
> -       region->virt_base = devm_ioremap_wc(smem->dev, region->aux_base, SZ_4K);
> +       region->virt_base = (void *)region->aux_base;
>         ptable_start = region->aux_base + region->size - SZ_4K;
>         /* map last 4k for toc */
> -       smem->ptable = devm_ioremap_wc(smem->dev, ptable_start, SZ_4K);
> +       smem->ptable = (struct smem_ptable *)(u64)ptable_start;
>
>         if (!region->virt_base || !smem->ptable)
>                 return -ENOMEM;
>
> @@ -1071,54 +969,29 @@ static int qcom_smem_map_toc(struct qcom_smem *smem, struct smem_region *region)
>  }
>
>  static int qcom_smem_map_global(struct qcom_smem *smem, u32 size)
>  {
> -       u32 phys_addr;
> +       u64 phys_addr;
>
>         phys_addr = smem->regions[0].aux_base;
>
>         smem->regions[0].size = size;
> -       smem->regions[0].virt_base = devm_ioremap_wc(smem->dev, phys_addr, size);
> +       smem->regions[0].virt_base = (void *)phys_addr;
>
>         if (!smem->regions[0].virt_base)
>                 return -ENOMEM;
>
>         return 0;
>  }
>
> -static int qcom_smem_resolve_mem(struct qcom_smem *smem, const char *name,
> -                                struct smem_region *region)
> -{
> -       struct device *dev = smem->dev;
> -       struct device_node *np;
> -       struct resource r;
> -       int ret;
> -
> -       np = of_parse_phandle(dev->of_node, name, 0);
> -       if (!np) {
> -               dev_err(dev, "No %s specified\n", name);
> -               return -EINVAL;
> -       }
> -
> -       ret = of_address_to_resource(np, 0, &r);
> -       of_node_put(np);
> -       if (ret)
> -               return ret;
> -
> -       region->aux_base = r.start;
> -       region->size = resource_size(&r);
> -
> -       return 0;
> -}
> -
> -static int qcom_smem_probe(struct platform_device *pdev)
> +int qcom_smem_init(void)
>  {
>         struct smem_header *header;
> -       struct reserved_mem *rmem;
>         struct qcom_smem *smem;
> -       unsigned long flags;
>         int num_regions;
> -       int hwlock_id;
> +       fdt_size_t reg_size = 0;
> +       u32 phandle;
> +       ofnode node, mem_node;
>         u32 version;
>         u32 size;
>         int ret;
>         int i;
> @@ -1126,85 +999,58 @@ static int qcom_smem_probe(struct platform_device *pdev)
>         if (__smem)
>                 return 0;
>
>         num_regions = 1;
> -       if (of_property_present(pdev->dev.of_node, "qcom,rpm-msg-ram"))
> -               num_regions++;
>
> -       smem = devm_kzalloc(&pdev->dev, struct_size(smem, regions, num_regions),
> +       node = ofnode_by_compatible(ofnode_root(), "qcom,smem");
> +       if (!ofnode_valid(node))
> +               return -ENODEV;
> +
> +       if (ofnode_has_property(node, "memory-region")) {
> +               ofnode_read_u32(node, "memory-region", &phandle);
> +               mem_node = ofnode_get_by_phandle(phandle);
> +       } else {
> +               mem_node = node;
> +       }
> +
> +       smem = kzalloc(sizeof(struct smem_region) * num_regions +
> +                      sizeof(struct qcom_smem),
>                             GFP_KERNEL);
> -       if (!smem)
> +       if (!smem) {
> +               log_err("Failed to allocate memory for smem\n");
>                 return -ENOMEM;
> +       }
>
> -       smem->dev = &pdev->dev;
>         smem->num_regions = num_regions;
>
> -       rmem = of_reserved_mem_lookup(pdev->dev.of_node);
> -       if (rmem) {
> -               smem->regions[0].aux_base = rmem->base;
> -               smem->regions[0].size = rmem->size;
> -       } else {
> -               /*
> -                * Fall back to the memory-region reference, if we're not a
> -                * reserved-memory node.
> -                */
> -               ret = qcom_smem_resolve_mem(smem, "memory-region", &smem->regions[0]);
> -               if (ret)
> -                       return ret;
> +       smem->regions[0].aux_base = ofnode_get_addr(mem_node);
> +       reg_size = ofnode_get_size(mem_node);
> +       if (smem->regions[0].aux_base == FDT_ADDR_T_NONE) {
> +               log_err("Failed to get base address\n");
> +               return -EINVAL;
>         }
> -
> -       if (num_regions > 1) {
> -               ret = qcom_smem_resolve_mem(smem, "qcom,rpm-msg-ram", &smem->regions[1]);
> -               if (ret)
> -                       return ret;
> -       }
> -
> +       smem->regions[0].size = reg_size;
>
>         ret = qcom_smem_map_toc(smem, &smem->regions[0]);
> -       if (ret)
> +       if (ret) {
> +               log_err("Failed to map toc\n");
>                 return ret;
> +       }
>
>         for (i = 1; i < num_regions; i++) {
> -               smem->regions[i].virt_base = devm_ioremap_wc(&pdev->dev,
> -                                                            smem->regions[i].aux_base,
> -                                                            smem->regions[i].size);
> -               if (!smem->regions[i].virt_base) {
> -                       dev_err(&pdev->dev, "failed to remap %pa\n", &smem->regions[i].aux_base);
> -                       return -ENOMEM;
> -               }
> +               smem->regions[i].virt_base = (void *)smem->regions[i].aux_base;
>         }
>
>         header = smem->regions[0].virt_base;
>         if (le32_to_cpu(header->initialized) != 1 ||
>             le32_to_cpu(header->reserved)) {
> -               dev_err(&pdev->dev, "SMEM is not initialized by SBL\n");
> +               log_err("SMEM is not initialized by SBL\n");
>                 return -EINVAL;
>         }
>
> -       hwlock_id = of_hwspin_lock_get_id(pdev->dev.of_node, 0);
> -       if (hwlock_id < 0) {
> -               if (hwlock_id != -EPROBE_DEFER)
> -                       dev_err(&pdev->dev, "failed to retrieve hwlock\n");
> -               return hwlock_id;
> -       }
> -
> -       smem->hwlock = hwspin_lock_request_specific(hwlock_id);
> -       if (!smem->hwlock)
> -               return -ENXIO;
> -
> -       ret = hwspin_lock_timeout_irqsave(smem->hwlock, HWSPINLOCK_TIMEOUT, &flags);
> -       if (ret)
> -               return ret;
>         size = readl_relaxed(&header->available) + readl_relaxed(&header->free_offset);
> -       hwspin_unlock_irqrestore(smem->hwlock, &flags);
>
>         version = qcom_smem_get_sbl_version(smem);
> -       /*
> -        * smem header mapping is required only in heap version scheme, so unmap
> -        * it here. It will be remapped in qcom_smem_map_global() when whole
> -        * partition is mapped again.
> -        */
> -       devm_iounmap(smem->dev, smem->regions[0].virt_base);
>         switch (version >> 16) {
>         case SMEM_GLOBAL_PART_VERSION:
>                 ret = qcom_smem_set_global_partition(smem);
>                 if (ret < 0)
> @@ -1215,63 +1061,19 @@ static int qcom_smem_probe(struct platform_device *pdev)
>                 qcom_smem_map_global(smem, size);
>                 smem->item_count = SMEM_ITEM_COUNT;
>                 break;
>         default:
> -               dev_err(&pdev->dev, "Unsupported SMEM version 0x%x\n", version);
> +               log_err("Unsupported SMEM version 0x%x\n", version);
>                 return -EINVAL;
>         }
>
>         BUILD_BUG_ON(SMEM_HOST_APPS >= SMEM_HOST_COUNT);
>         ret = qcom_smem_enumerate_partitions(smem, SMEM_HOST_APPS);
> -       if (ret < 0 && ret != -ENOENT)
> +       if (ret < 0 && ret != -ENOENT) {
> +               log_err("Failed to enumerate partitions\n");
>                 return ret;
> +       }
>
>         __smem = smem;
>
> -       smem->socinfo = platform_device_register_data(&pdev->dev, "qcom-socinfo",
> -                                                     PLATFORM_DEVID_NONE, NULL,
> -                                                     0);
> -       if (IS_ERR(smem->socinfo))
> -               dev_dbg(&pdev->dev, "failed to register socinfo device\n");
> -
>         return 0;
>  }
> -
> -static void qcom_smem_remove(struct platform_device *pdev)
> -{
> -       platform_device_unregister(__smem->socinfo);
> -
> -       hwspin_lock_free(__smem->hwlock);
> -       __smem = NULL;
> -}
> -
> -static const struct of_device_id qcom_smem_of_match[] = {
> -       { .compatible = "qcom,smem" },
> -       {}
> -};
> -MODULE_DEVICE_TABLE(of, qcom_smem_of_match);
> -
> -static struct platform_driver qcom_smem_driver = {
> -       .probe = qcom_smem_probe,
> -       .remove_new = qcom_smem_remove,
> -       .driver  = {
> -               .name = "qcom-smem",
> -               .of_match_table = qcom_smem_of_match,
> -               .suppress_bind_attrs = true,
> -       },
> -};
> -
> -static int __init qcom_smem_init(void)
> -{
> -       return platform_driver_register(&qcom_smem_driver);
> -}
> -arch_initcall(qcom_smem_init);
> -
> -static void __exit qcom_smem_exit(void)
> -{
> -       platform_driver_unregister(&qcom_smem_driver);
> -}
> -module_exit(qcom_smem_exit)
> -
> -MODULE_AUTHOR("Bjorn Andersson <bjorn.andersson@sonymobile.com>");
> -MODULE_DESCRIPTION("Qualcomm Shared Memory Manager");
> -MODULE_LICENSE("GPL v2");
> diff --git a/include/soc/qcom/smem.h b/include/soc/qcom/smem.h
> index f946e3beca21..a955db08c0f0 100644
> --- a/include/soc/qcom/smem.h
> +++ b/include/soc/qcom/smem.h
> @@ -3,18 +3,13 @@
>  #define __QCOM_SMEM_H__
>
>  #define QCOM_SMEM_HOST_ANY -1
>
> +int qcom_smem_init(void);
> +
>  bool qcom_smem_is_available(void);
>  int qcom_smem_alloc(unsigned host, unsigned item, size_t size);
>  void *qcom_smem_get(unsigned host, unsigned item, size_t *size);
>
>  int qcom_smem_get_free_space(unsigned host);
>
> -phys_addr_t qcom_smem_virt_to_phys(void *p);
> -
> -int qcom_smem_get_soc_id(u32 *id);
> -int qcom_smem_get_feature_code(u32 *code);
> -
> -int qcom_smem_bust_hwspin_lock_by_host(unsigned int host);
> -
>  #endif
>
> --
> 2.47.0
>