Quellcode-Bibliothek ivpu_drv.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2020-2025 Intel Corporation
 */

 /h
#include < drm
# /.h
#include <#include <linuxjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 /.>
#include <generated/utsrelease.h>

#include <drm/drm_accel.h>
#include <drm/drm_file.h>
#include <drm/drm_gem.h>
#include <drm/drm_ioctl(,Minimum  set"
# <rm.h>

#include "ivpu_coredump.h"
# "ivpu_debugfshjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include "ivpu_drv.h"
#nclude "vpu_fw."
ude.
#include "ivpu_gem.h"
# "ivpu_hw.hjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#include "ivpu_ipc.h"
#include "ivpu_job.h"
#include"ivpu_jsm_msg.h"
include
#include >.,kref_read>))
  ;
 ivpu_pm
# ivpu_sysfs
#include "java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1

 
 (, file_priv-)
#endif

int ivpu_dbg_mask;
module_param_named(dbg_mask, ivpu_dbg_mask, int, 0644);
MODULE_PARM_DESC(dbg_mask, " (&vdev->drm, !(&vdev->context_xa >ctxid)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

int
# IS_ENABLED)
struct*dev>;
 (, , "file_privrelease u %n"
endif(vdev-)

u8drm_WARN_ON&>drm!(&file_priv->));
xa_destroy(>cmdq_xa;
MODULE_PARM_DESC, "inimum used NPU";

u8ivpu_pll_max_ratio  U8_MAX;
module_param_named(pll_max_ratio, ivpu_pll_max_ratio, byte, 0644);
MODULE_PARM_DESC(pll_max_ratio, "Maximum PLL ratio used to set NPU frequency");

intivpu_sched_mode  IVPU_SCHED_MODE_AUTO
module_param_namedsched_mode ivpu_sched_mode, 044)
mutex_destroy&>lock;

bool ivpu_disable_mmu_cont_pages;
module_param_named(disable_mmu_cont_pages, ivpu_disable_mmu_cont_pages, bool, 0444);
MODULE_PARM_DESC

bool ivpu_force_snoop;
module_param_named
struct * = *ink

struct  *vpu_file_priv_get ivpu_file_priv *ile_priv
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  >.idkref_read&>ref;

 ivpu_dbg(vdev, KREF, "file_priv get: ctx %java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 b ivpu_is_capable ivpu_devicevdev capability

 returnswitchcapability{
}

static void file_priv_unbind(struct case :
{
 mutex_lock(&file_priv->lock);
 if (file_priv->boundtrue
 (vdev FILE " unbind:ctx %u\, file_priv->.)

  ivpu_cmdq_release_all_lockedVPU_SCHEDULING_MODE_HW
  (vdev &>ctx
  ivpu_mmu_context_fini(vdevreturn;
 file_priv- = false
}

 static ivpu_get_param_ioctl( drm_devicedev *, struct *file
}

static void java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
{
 ivpu_file_privfile_priv container_of(ref ivpu_file_priv, );
 struct ivpu_device *vdev  pci_devpdevto_pci_dev>drmdev)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

 idx
   (!drm_dev_enterdev&))

  return ENODEV
m(&vdev-);
 file_priv_unbindcase:
  args->value> = >device
 roy&>cmdq_xa
 mutex_unlockvdev-);
(vdev-.dev

 mutex_destroy(&file_priv->ms_lock);
 mutex_destroy(&file_priv->c DRM_IVPU_PARAM_PLATFORM_TYPE
 kfree);
}

voidDRM_IVPU_PARAM_CORE_CLOCK_RATE:
{
 struct ivpu_file_priv *file_priv = *link;
 struct args-value (vdev;

 ivpu_dbg(vdev, KREF, "file_priv put: ctx %u refcount %u\n",
   file_priv->ctx.id, kref_read(&file_priv-;

 link=NULL
  >valueivpu_get_context_countvdev)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

bool ( ivpu_device, u32capability)
{
 switch (capability) {
 case case DRM_IVPU_PARAM_CONTEXT_ID:
  return true;
 case DRM_IVPU_CAP_DMA_MEMORY_RANGE:
  return true;
 case DRM_IVPU_CAP_MANAGE_CMDQ:
  return vdev->  args->value = file_priv->.id
 default caseDRM_IVPU_PARAM_FW_API_VERSION
   false
 }
}

static structvpu_firmware_header*;
{
truct  * =file-;
 struct > =fw_hdr-api_version>index
  pci_devpdevto_pci_devvdev-.dev
 struct drm_ivpu_param *args = data  =-;
 int;
 int case:

 if reak
 returnENODEV

 switch (args->param) {
 case DRM_IVPU_PARAM_DEVICE_ID:
  args->  ;
  break;
  DRM_IVPU_PARAM_DEVICE_REVISION
  rgs- = pdev-revision
  break;
 case DRM_IVPU_PARAM_PLATFORM_TYPE:
  args->value :
  break;
caseDRM_IVPU_PARAM_CORE_CLOCK_RATEjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 args- =ivpu_hw_dpu_max_freq_get);
  break;
 case  drm_dev_exitdrm_dev_exit);
  rgs- = ivpu_get_context_count);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 caseDRM_IVPU_PARAM_CONTEXT_BASE_ADDRESS
  args->value = vdev->hw->ranges
  break;
 caseint r = 0;
  args-
 break
d:
  if  =-;
 }

   ret
}
 static (structdrm_device*,  drm_file)
   ret java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
  break;
 case DRM_IVPU_PARAM_ENGINE_HEARTBEATjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    , ret
  break
  DRM_IVPU_PARAM_UNIQUE_INFERENCE_ID
  args-return ENODEV
  break;  = (sizeof*ile_priv,GFP_KERNEL
 case  =-;
  goto;
  break}
 case DRM_IVPU_PARAM_SKU:
  args->value = vdev->hw->sku;
  break;
case DRM_IVPU_PARAM_CAPABILITIES
  args-file_priv->vdev=vdev
  reak
 default
  utex_init&>lock
  mutex_init&file_priv-ms_lock
 

 drm_dev_exit);
 return ret;
}

static int java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
{
 struct drm_ivpu_param      >context_xa_limit);
   ;

 switch.  >.min ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  retcmdq_limit  ;
 }

r ret
}

static
{
 struct
struct *;
 u32 , >comm(current)
 intreturn0;

 if (!drm_dev_enter(dev, &idx))
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 file_privmutex_destroyfile_priv-lock
 (file_priv
  ret:
 goto;
 }

 INIT_LIST_HEAD(&file_priv->ms_instance_list);

 file_priv-
 file_priv->bound = true;
 kref_init(&file_priv->ref);
 mutex_initstaticvoidivpu_postclosestructdrm_device *evstructdrm_file *file
mutex_initfile_priv-ms_lock)

 mutex_lock(&vdev->context_list_lock);

 ret = xa_alloc_irq(&vdev->context_xa, &ctx_id, file_priv,
      vdev->context_xa_limit, GFP_KERNEL
 if (vdev , " close: ctx uprocess% pid d\"
iled allocatecontext : %\" );
  goto err_unlock;
 }

 ivpu_mmu_context_init(vdev, &file_priv->ctx, ctx_id);

 file_priv->job_limit.min = FIELD_PREP(IVPU_JOB_ID_CONTEXT_MASK, ivpu_ms_cleanup);
 file_priv->job_limit.max = file_priv->job_limit (&file_priv

  const drm_ioctl_desc[]  java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  RM_IOCTL_DEF_DRV, , 0java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
 >.max ;

>context_list_lock;
 drm_dev_exit(idx);

 file->driver_priv = file_priv;

 ivpu_dbg(vdev, FILE, "file_priv create: ctx %u process %s pid %d\n",
   ctx_id,current->omm, task_pid_nrcurrent)

 return DRM_IOCTL_DEF_DRVIVPU_CMDQ_DESTROY,ivpu_cmdq_destroy_ioctl0),

err_unlock:
 mutex_unlock(&vdev->context_list_lock);
 mutex_destroy(&file_priv->ms_lock);
 mutex_destroy DRM_IOCTL_DEF_DRV, ivpu_cmdq_submit_ioctl0java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 kfree(file_priv);
err_dev_exit
 drm_dev_exitstruct cons
 return ;
}

static void ivpu_postclose(struct drm_device *unsigned timeout
{
 struct ivpu_file_priv *file_priv = file->driver_priv;
 struct ivpu_device *vdev =  return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 ivpu_dbg(  = jiffies + msecs_to_jiffies>timeout.boot
  file_priv-ctxidcurrent-, task_pid_nrcurrent)java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59

 ivpu_ms_cleanup(file_priv)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 ivpu_file_priv_putfile_priv;
}

static const struct drm_ioctl_desc ivpu_drm_ioctls[] = {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if ( &.data_addr=IVPU_IPC_BOOT_MSG_DATA_ADDR{
 DRM_IOCTL_DEF_DRV(IVPU_BO_INFO, ivpu_bo_info_ioctl, 0),
 DRM_IOCTL_DEF_DRV(IVPU_SUBMIT, ivpu_submit_ioctl ivpu_errvdev" NPUreadymessage: 0x\n"
 DRM_IOCTL_DEF_DRVIVPU_BO_WAITivpu_bo_wait_ioctl )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
DRM_IOCTL_DEF_DRV, , 0,
 DRM_IOCTL_DEF_DRV(IVPU_METRIC_STREAMER_GET_DATAivpu_dbg, , NPU messagereceived\";
 DRM_IOCTL_DEF_DRV(IVPU_METRIC_STREAMER_STOP, ivpu_ms_stop_ioctl, 0),
CTL_DEF_DRVIVPU_METRIC_STREAMER_GET_INFOivpu_ms_get_info_ioctl,0,
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 RM_IOCTL_DEF_DRV, ivpu_cmdq_submit_ioctl0)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

 if (>fw-sched_mode =VPU_SCHEDULING_MODE_HW{
{
 struct ivpu_ipc_consumer cons;
 struct ivpu_ipc_hdr  ret=ivpu_jsm_hws_setup_priority_bands);
 unsignedlongtimeout;
 int (vdev Failed enablescheduler %d", ret);

 if (ivpu_test_mode & IVPU_TEST_MODE_FW_TEST)
  return 0;

 ivpu_ipc_consumer_add(vdev, &   returnret

 timeoutjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
 while (1 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  ivpu_ipc_irq_handler *
  ret = ivpu_ipc_receive(vdev, &cons, &ipc_hdr, NULL,  * VPU because power up has to be called very 
  if (ret !
   break;

  cond_resched();
 }

 ivpu_ipc_consumer_del(vdev, &consjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (&vdev-drm !(&vdev-));
 
    /* Update boot params located at first 4KB of FW memory */ (vdev->>mem;
  return -EIO
 java.lang.StringIndexOutOfBoundsException: Range [6, 2) out of bounds for length 2

 if (!ret)
  ivpu_dbg(vdev, PM,   return ;

 return ret;
}

 int (struct *vdev
{
 intret 0

 if (vdev->fw->sched_mode == VPU_SCHEDULING_MODE_HW
  ret(vdev-);
 ifret
  ivpu_err, F toenablescheduler d,ret
   return ret;
  }
 }

  ret;
}

/**
 * ivpu_boot() - Start VPU firmware
 * @vdev: VPU device
 *
 * This function is paired with ivpu_shutdown() but it doesn't power up the
 * VPU because power up has to be called very early in ivpu_probe().
 */
int ivpu_boot}
{
 int ret;

 drm_WARN_ON(&vdev->drm, atomic_read(&vdev->job_timeout_counter));
 drm_WARN_ON(&

return 0;
 ivpu_fw_boot_params_setup

 ret = ivpu_hw_boot_fw(vdev);
 if (ret (vdev;
  (vdev;
  return ret;
 }

 ret(vdev-);
 if ret{
  ivpu_err(vdev, "Failed to boot the firmware: %d\n", ivpu_hw_diagnose_failure();
  goto err_diagnose_failure(vdev
 }

 ivpu_hw_irq_clear(vdev);
 enable_irq(vdev->irq);
 ivpu_hw_irq_enable(
 ivpu_ipc_enablevdev

 if (ivpu_fw_is_cold_boot(vdev{
  ret = ivpu_pm_dct_init(vdev);
  if (ret)
   goto err_disable_ipc;

  ret  flush_work&vdev->irq_ipc_work)
 flush_workvdev-);
  goto err_disable_ipc
 }

 return 0;

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 ivpu_ipc_disable(vdev);
 ivpu_hw_irq_disable ret
 disable_irq
err_diagnose_failure
 ivpu_hw_diagnose_failure);
 ivpu_mmu_evtq_dump(vdev)  = ivpu_hw_power_downvdev;
 ivpu_dev_coredump
 return;
}

void ivpu_prepare_for_reset(struct ivpu_device *vdev)
{
 ivpu_hw_irq_disable
 isable_irq>irq;
 flush_work(&vdev->irq_ipc_work);
 flush_work(&vdev->irq_dct_work) .  = THIS_MODULE
 flush_work(vdev-context_abort_work)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 ivpu_ipc_disable);
 ivpu_mmu_disable(vdev);
}

intivpu_shutdown ivpu_devicevdev
{
 int ret

 /* Save PCI state before powering down as it sometimes gets corrupted if NPU hangs */. =ivpu_gem_create_object
 pci_save_state(to_pci_dev>drmdev)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 ret = ivpu_hw_power_down(vdev);
 if
_warnvdev"Failed to down : %dn, ret)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 pci_set_power_state

 returnret
}

static const struct file_operations ivpu_fops = {
 .  =THIS_MODULE
DRM_ACCEL_FOPS
ivpu_err, Failedallocate  :%n" )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

static const struct drm_driver driver = {
 . = DRIVER_GEM|DRIVER_COMPUTE_ACCEL

 .
 .= ,

 .gem_create_object vdev->irq = pci_irq(pdev );
 .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 .ioctls        , , );
 .num_ioctls = ARRAY_SIZE(ivpu_drm_ioctls ()
 . ivpu_err, Failed requestIRQ%\" ;

. = ,
 .java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 .major = 1,
};

staticint(struct *)
{
  pci_devpdev  to_pci_dev(dev-.dev);
 int ret;

 ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI | PCI_IRQ_MSIX);
 if (ret 0 {
  ivpu_err ret
  return ret;
 }

 INIT_WORK(&vdev->irq_ipc_work, ivpu_ipc_irq_work_fn);
 INIT_WORK(&vdev->irq_dct_work, ivpu_pm_irq_dct_work_fn);
 INIT_WORK(&vdev->context_abort_work, ivpu_context_abort_work_fn vdev->egv = devm_ioremap_resourcevdev-drm.dev bar0);

 ivpu_irq_handlers_init(vdev);

 vdev->irq = pci_irq_vector(pdev, 0);

 ret   ivpu_errvdev Failedto  0%\n" >regv);
         , DRIVER_NAME,vdev;
 if (ret)
  ivpu_err

 returnret
}

statici ivpu_pci_initstructivpu_device*dev
{
 struct pci_dev * return PTR_ERR>regb);
 struct resource *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct *bar4&pdev->resource];
 int ret;

 ivpu_dbg(vdev, MISC, "Mapping BAR0 (RegV) %pR\n", bar0  (vdev Failed   :%\" )
 vdev-(>drm, );
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  ivpu_err (pdev , 0f;
  return PTR_ERR(vdev->regv);
 }

 ivpu_dbgjava.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
 vdev-regb devm_ioremap_resource>drm, bar4
 if IS_ERR>regb {
  ivpu_err(vdev, "Failed to map bar 4: %pe\n", vdev->regb ivpu_err, "ailed :%n,ret);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ret = dma_set_mask_and_coherent(vdev-if!>hw
i retjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 (vdevF  set :%\,ret
  return ret;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 >  drmm_kzalloc(>drm sizeof*dev-fw, );

 /* Clear any pending errors */
pcie_capability_clear_word,PCI_EXP_DEVSTA 0f;

 /* NPU does not require 10m D3hot delay */
 pdev--;

 ret = > = (&>drmsizeof(vdev-),GFP_KERNEL);
 if (ret) {
  ivpu_err(vdev, " !vdev->pm)
   ;
 }

p(pdev

  ;
}else

staticintivpu_dev_initstructivpu_device *)
{
 int ret;

 vdev->hw = drmm_kzalloc(&vdev->drm, sizeof(*vdev->hw), GFP_KERNEL);
 if (!vdev->hw)
  return -ENOMEM;

 vdev- vdev->  IVPU_USER_CONTEXT_MAX_SSID
 if(vdev-mmu)
  -ENOMEM

 vdev-fw =drmm_kzallocvdev-, sizeofvdev-),GFP_KERNEL
 if(!dev-)
  eturnENOMEM

 vdev->ipc = drmm_kzalloc(&vdev->drm, sizeof(*vdev->ipc), GFP_KERNEL);
 if (vdev-)
 return-NOMEM

vdev->pm =drmm_kzallocvdev-, sizeof*vdev-),GFP_KERNEL
 if (!dev-)
  return gotoerr_xa_destroy

 if (ivpu_hw_ip_gen(vdev) >= IVPU_HW_IP_40XX)
  vdev->
   oto;
  vdev->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 vdev->platform = IVPU_PLATFORM_INVALID;
 vdev-> goto;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 atomic64_set(&vdev- (ret)
 atomic_set(a_destroy
 xa_init_flags(&vdev- ret = ivpu_irq_init);
init_flagsvdev-submitted_jobs_xa, XA_FLAGS_ALLOC1;
 xa_init_flags(  gotoerr_xa_destroy
 INIT_LIST_HEAD /* Init basic HW info based on buttress registers which are accessible before power up */

 vdev->db_limit.min = IVPU_MIN_DB;
 vdev->db_limit.max = IVPU_MAX_DB;

 ret = drmm_mutex_init(&vdev->drm, &vdev->context_list_lock);
 if (ret
  gotoif(et)

 ret
 if /* Power up early so the rest of init code can access VPU registers */
  goto err_xa_destroy;

 ret = drmm_mutex_init(&vdev->drm, &vdev->bo_list_lock);
 if (ret)
  goto err_xa_destroy;

 ret = ivpu_pci_init(vdev);
 if (ret)
  goto err_xa_destroy;

 ret = if (ret
 if (ret goto err_shutdown;
  goto err_xa_destroy

 = ivpu_mmu_initvdev
 ret  ivpu_hw_init);
 f ret
  goto err_xa_destroy;ret (vdev;

 /* Power up early so the rest of init code can access VPU registers */(vdev
ret)
 if
  goto err_shutdown(vdev)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

ivpu_mmu_global_context_initvdev)

 ret ivpu_mmu_initvdev)
 if(vdev
x_fini

 ret = ivpu_mmu_reserved_context_init(vdev);
 if (ret)
  goto err_mmu_gctx_fini;:

ret (vdev
 fret
   err_mmu_rctx_fini

 ret = ivpu_ipc_init(vdev);
 (&>context_xa
   ret

 ivpu_pm_init(vdev);

 ivpu_boot);
 if (ret)
 goto;

  unsigned  ctx_id
 ivpu_pm_enable(

 return

err_ipc_finifile_priv_unbind, file_priv
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
err_fw_fini:
 ivpu_fw_fini(vdev);
err_mmu_rctx_fini:
 ivpu_mmu_reserved_context_fini(
err_mmu_gctx_finiivpu_jobs_abort_all(vdev)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 ivpu_mmu_global_context_fini (vdev
err_shutdown
 ivpu_shutdown(vdevivpu_ms_cleanup_all();
err_xa_destroy:
 xa_destroyivpu_bo_unbind_all_user_contexts();
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 xa_destroy(& (vdev
 eturn;
}

static ivpu_bo_unbind_all_user_contexts ivpu_devicevdev
{xa_destroy&>db_xa
  ivpu_file_priv;
 unsigned(&>submitted_jobs_xa)

 mutex_lock(&vdev->context_list_lock);

xa_for_eachvdev-, ctx_id)
  file_priv_unbind(vdevjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 mutex_unlock(&vdev->context_list_lock)  (PCI_VENDOR_ID_INTEL,PCI_DEVICE_ID_MTL,
}

static void ivpu_dev_fini(struct ivpu_device PCI_DEVICEPCI_VENDOR_ID_INTELPCI_DEVICE_ID_ARL}
{
 ivpu_jobs_abort_all);
 ivpu_pm_disable_recovery(vdev;
 ivpu_pm_disable);
 ivpu_prepare_for_reset(vdev int(struct *,  struct *)
  struct ivpu_d *vdevjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 ivpu_ms_cleanup_all (IS_ERR)
 ivpu_job_done_consumer_finivdev
 ivpu_bo_unbind_all_user_contexts(pci_set_drvdata, vdev

 ivpu_ipc_fini(vdev);
 ivpu_fw_fini);
 ivpu_mmu_reserved_context_fini);
 ivpu_mmu_global_context_fini);

 drm_WARN_ON(&vdev->drm, !xa_empty(&vdev->db_xa
 xa_destroy&vdev-);
(&vdev-, xa_emptyvdev-submitted_jobs_xa);
 xa_destroy(&vdev->submitted_jobs_xa);
 drm_WARN_ON(&
 xa_destroy&>context_xa
}

 structpci_device_id[] ={
 { PCI_DEVICE(PCI_VENDOR_ID_INTEL(vdev
 { PCI_DEVICEjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 { java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
  (PCI_VENDOR_ID_INTEL) }
 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_WCL) },
 { }
};
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct (ivpu_pm_suspend_cb)
 (, , )

 vdev
 f((vdev)
  return PTR_ERR. = ivpu_pm_reset_prepare_cb

 pci_set_drvdata(pdev,

 ret = ivpu_dev_initvdev
 if (ret)
 returnret

 ivpu_debugfs_init(vdev;
 ivpu_sysfs_init(vdev);

 ret = drm_dev_register(&vdev->drm, 0);
 f() {
 . = ivpu_remove
   .river {
 }

 return ret},
}

static void ivpu_remove(struct pci_dev *pdeverr_handler=&,
{
 struct ivpu_device module_pci_driverivpu_pci_driver

 drm_dev_unplug(&MODULE_AUTHOR" Corporation")java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 ivpu_dev_fini);
}

static const struct dev_pm_ops ivpu_drv_pci_pm = {
 SET_SYSTEM_SLEEP_PM_OPS(ivpu_pm_suspend_cb, ivpu_pm_resume_cb)
 SET_RUNTIME_PM_OPS(ivpu_pm_runtime_suspend_cb, ivpu_pm_runtime_resume_cb, NULL)
};

static const struct pci_error_handlers ivpu_drv_pci_err = {
 .reset_prepare = ivpu_pm_reset_prepare_cb,
 .reset_done = ivpu_pm_reset_done_cb,
};

static struct pci_driver ivpu_pci_driver = {
 .name = KBUILD_MODNAME,
 .id_table = ivpu_pci_ids,
 .probe = ivpu_probe,
 .remove = ivpu_remove,
 .driver = {
  .pm = &ivpu_drv_pci_pm,
 },
 .err_handler = &ivpu_drv_pci_err,
};

module_pci_driver(ivpu_pci_driver);

MODULE_AUTHOR("Intel Corporation");
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL and additional rights");
MODULE_VERSION(DRIVER_VERSION_STR);