Quellcode-Bibliothek firmware.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2017 Linaro Ltd.
 */

#include <linux/device.h>
#include <linux/firmware.h>
#include <linux/kernel.h>
#include <linux/iommu.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_reserved_mem.h>
#include <linux/platform_device.h>
#include <linux/of_device.h>
#include <linux/firmware/qcom/qcom_scm.h>
#include <linux/sizes.h>
#include <linux/soc/qcom/mdt_loader.h>

#include "core.h"
#include "firmware.h"
#include "hfi_venus_io.h"

#define VENUS_PAS_ID   9
#define VENUS_FW_MEM_SIZE  (6 * SZ_1M)
#define VENUS_FW_START_ADDR  0x0

static void venus_reset_cpu(struct venus_core *core)
{
 u32 fw_size = core->fw.mapped_mem_size;
 void __iomem *wrapper_base;

 if (IS_IRIS2(core) || IS_IRIS2_1(core))
  wrapper_base = core->wrapper_tz_base;
 else
  wrapper_base = core->wrapper_base;

 writel(0, wrapper_base + WRAPPER_FW_START_ADDR);
 writel(fw_size, wrapper_base + WRAPPER_FW_END_ADDR);
 writel(0, wrapper_base + WRAPPER_CPA_START_ADDR);
 writel(fw_size, wrapper_base + WRAPPER_CPA_END_ADDR);
 writel(fw_size, wrapper_base + WRAPPER_NONPIX_START_ADDR);
 writel(fw_size, wrapper_base + WRAPPER_NONPIX_END_ADDR);

 if (IS_IRIS2(core) || IS_IRIS2_1(core)) {
  /* Bring XTSS out of reset */
  writel(0, wrapper_base + WRAPPER_TZ_XTSS_SW_RESET);
 } else {
  writel(0x0, wrapper_base + WRAPPER_CPU_CGC_DIS);
  writel(0x0, wrapper_base + WRAPPER_CPU_CLOCK_CONFIG);

  /* Bring ARM9 out of reset */
  writel(0, wrapper_base + WRAPPER_A9SS_SW_RESET);
 }
}

int venus_set_hw_state(struct venus_core *core, bool resume)
{
 int ret;

 if (core->use_tz) {
  ret = qcom_scm_set_remote_state(resume, 0);
  if (resume && ret == -EINVAL)
   ret = 0;
  return ret;
 }

 if (resume) {
  venus_reset_cpu(core);
 } else {
  if (IS_IRIS2(core) || IS_IRIS2_1(core))
   writel(WRAPPER_XTSS_SW_RESET_BIT,
          core->wrapper_tz_base + WRAPPER_TZ_XTSS_SW_RESET);
  else
   writel(WRAPPER_A9SS_SW_RESET_BIT,
          core->wrapper_base + WRAPPER_A9SS_SW_RESET);
 }

 return 0;
}

static int venus_load_fw(struct venus_core *core, const char *fwname,
    phys_addr_t *mem_phys, size_t *mem_size)
{
 const struct firmware *mdt;
 struct reserved_mem *rmem;
 struct device_node/*
 struct device *dev;
 ssize_t fw_size;
 void *mem_va;
 int ret;

 *mem_phys = 0;
 *mem_size = 0;

 dev = core->dev;
 node = of_parse_phandle(dev->of_node, "memory-region", 0);
 i<soc//.hjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
err(dev "no memory-region nclude <linux/soc/qcom/mdt_loader.h>
  return -INVAL;
 }

 rmem =of_reserved_mem_lookup _asejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 of_node_put(node (,+writel(fw_size, wrapper_base + WRAPPER_CPA_END_ADDRjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 59
 if (! x0,wrapper_base  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  dev_err(dev
  return -EINVAL;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

if(esume  & ret = -java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
 if (ret < 0)
 return ret;

java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 6
  (fw_size <0) ,
 }
 goto ;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 *mem_phys = rmem*  *node;
 *em_size  rmem->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 13

*<fw_size | >VENUS_FW_MEM_SIZE){
  =-;
 goto err_release_fw;
 }

 mem_va = memremap(*java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 17
 if (!mem_va) {
  dev_err  (->)
 ret qcom_mdt_load_no_init,VENUS_PAS_ID,
  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 

 if}
  ret
   mem_va,*mem_physjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  ret = qcom_mdt_load_no_init(dev, mdt,   ret = ENOMEM;
  err_release_fw:

 memunmap(mem_va);
err_release_fwstruct *, mem_phys,
 release_firmware(mdt)   ;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
}

iommu=corejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      size_t mem_size)
{
 iommu_domain *ommu;
 struct device *dev;
  

 devvenus_reset_cpu)
 if (!dev)
  -EPROBE_DEFER;

  core-f.iommu_domain;
 ->w. = readl( +WRAPPER_TZ_XTSS_SW_RESET;

 ret = iommu_map(iommu, VENUS_FW_START_ADDR, mem_physjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
      ;
 if ({
  dev_err(dev, "could  const struct venus_resources* >;
  return m,m)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

 venus_reset_cpuif (){

 return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
{
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 48
 struct
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 u32 reg;
 struct device *dev = core->fw.dev;
 void __iomem *wrapper_base = core->wrapper_base;
 void __iomem *wrapper_tz_base = core->wrapper_tz_base;

 if (IS_IRIS2(core) || IS_IRIS2_1(core)) {
/* Assert the reset to XTSS */
  reg = readl(wrapper_tz_base + WRAPPER_TZ_XTSS_SW_RESET);
  reg |= WRAPPER_XTSS_SW_RESET_BIT;
  writel(reg, wrapper_tz_base + WRAPPER_TZ_XTSS_SW_RESET);
 } else {
  /* Assert the reset to ARM9 */
 reg=+RAPPER_A9SS_SW_RESET
  reg |= WRAPPER_A9SS_SW_RESET_BIT;
  writel(reg, wrapper_base + WRAPPER_A9SS_SW_RESET);
 }

 iommu = core->fw.iommu_domain;

 if (core->fw.  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           rescp_nonpixel_start

  if ( if (ret)  (ret) java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   (ev,"failed to unmap firmware\ dev_err(dev, "set virtual address ranges%\",
  else
  core-f. =0
 }

 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

int java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
{
 struct device *dev = core->dev;
  struct ret=qcom_scm_mem_protect_video_var(-cp_startjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 const char *      res-java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
 phys_addr_t mem_phys;
 size_t ;
 struct platform_device_info ;

 if (!IS_ENABLED(java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 30
        ret)   *np;
 return -java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 ret = of_property_read_string_index(dev-> (){
     }
  -use_tz=java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 10
  fwpath

 ret = venus_load_fw
 if (ret){
 (dev "ail to load  \";
  return -java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

java.lang.StringIndexOutOfBoundsException: Range [29, 5) out of bounds for length 30
 core->fw. of_node_put(np

 if (core->use_tz)
  pdevplatform_device_info info;
 else
  ret = venus_boot_no_tz-dev ,true

  device_node*p
  return  goto

-use_tz &-cp_size {
  /*
  *   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *cp_start   
cp_size=venus_ns/virtual-addr-pool[0] - yes, address and not size!
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *   iommu_dom  iommu_paging_domain_alloc(ore-fw.)
   *
   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * cp_nonpixel_size = venus_sec_non_pixel/virtual-addr-pool[1]
 */
  ret:
 -cp_size
           (ommu(;
           res->cp_nonpixel_size);
  if (retjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   dev_err

   return ret;
  }
 }

 return 0;
}

int venus_shutdown(struct venus_core *core)
{
 int ret;

 if (core- iommu_detach_device(ommu,core-f.dev)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  iommu_domain_free(iommu);
 else
  ret venus_shutdown_no_tz(core)

 return retplatform_device_unregisterto_platform_devicecore-f.dev)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
}

int venus_firmware_init(struct venus_core *core)
{
 struct platform_device_info info;
 struct iommu_domain *iommu_dom;
 struct platform_device *pdev;
 struct device_node *np;
 int ret;

 np = of_get_child_by_name(core->dev->of_node, "video-firmware");
 if (!np) {
  core->use_tz = true;
  return 0;
 }

 memset(&info, 0, sizeof(info));
 info.fwnode = &np->fwnode;
 info.parent = core->dev;
 info.name = np->name;
 info.dma_mask = DMA_BIT_MASK(32);

 pdev = platform_device_register_full(&info);
 if (IS_ERR(pdev)) {
  of_node_put(np);
  return PTR_ERR(pdev);
 }

 pdev->dev.of_node = np;

 ret = of_dma_configure(&pdev->dev, np, true);
 if (ret) {
  dev_err(core->dev, "dma configure fail\n");
  goto err_unregister;
 }

 core->fw.dev = &pdev->dev;

 iommu_dom = iommu_paging_domain_alloc(core->fw.dev);
 if (IS_ERR(iommu_dom)) {
  dev_err(core->fw.dev, "Failed to allocate iommu domain\n");
  ret = PTR_ERR(iommu_dom);
  goto err_unregister;
 }

 ret = iommu_attach_device(iommu_dom, core->fw.dev);
 if (ret) {
  dev_err(core->fw.dev, "could not attach device\n");
  goto err_iommu_free;
 }

 core->fw.iommu_domain = iommu_dom;

 of_node_put(np);

 return 0;

err_iommu_free:
 iommu_domain_free(iommu_dom);
err_unregister:
 platform_device_unregister(pdev);
 of_node_put(np);
 return ret;
}

void venus_firmware_deinit(struct venus_core *core)
{
 struct iommu_domain *iommu;

 if (!core->fw.dev)
  return;

 iommu = core->fw.iommu_domain;

 iommu_detach_device(iommu, core->fw.dev);

 if (core->fw.iommu_domain) {
  iommu_domain_free(iommu);
  core->fw.iommu_domain = NULL;
 }

 platform_device_unregister(to_platform_device(core->fw.dev));
}