Quelle  amdgpu_irq.c   Sprache: C

/*
 * Copyright 2008 Advanced Micro Devices, Inc.
 * Copyright 2008 Red Hat Inc.
 * Copyright 2009 Jerome Glisse.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Dave Airlie
 *          Alex Deucher
 *          Jerome Glisse
 */

/**
 * DOC: Interrupt Handling
 *
 * Interrupts generated within GPU hardware raise interrupt requests that are
 * passed to amdgpu IRQ handler which is responsible for detecting source and
 * type of the interrupt and dispatching matching handlers. If handling an
 * interrupt requires calling kernel functions that may sleep processing is
 * dispatched to work handlers.
 *
 * If MSI functionality is not disabled by module parameter then MSI
 * support will be enabled.
 *
 * For GPU interrupt sources that may be driven by another driver, IRQ domain
 * support is used (with mapping between virtual and hardware IRQs).
 */

#include <linux/irq.h>
#include <linux/pci.h>

#include <drm/drm_vblank.h>
#include <drm/amdgpu_drm.h>
#include <drm/drm_drv.h>
#include "amdgpu.h"
#include "amdgpu_ih.h"
#include "atom.h"
#include "amdgpu_connectors.h"
#include "amdgpu_trace.h"
#include "amdgpu_amdkfd.h"
#include "amdgpu_ras.h"

#include <linux/pm_runtime.h>

#ifdef CONFIG_DRM_AMD_DC
#include "amdgpu_dm_irq.h"
#endif

#define AMDGPU_WAIT_IDLE_TIMEOUT 200

const char *soc15_ih_clientid_name[] = {
 "IH",
 "SDMA2 or ACP",
 "ATHUB",
 "BIF",
 "SDMA3 or DCE",
 "SDMA4 or ISP",
 "VMC1 or PCIE0",
 "RLC",
 "SDMA0",
 "SDMA1",
 "SE0SH",
 "SE1SH",
 "SE2SH",
 "SE3SH",
 "VCN1 or UVD1",
 "THM",
 "VCN or UVD",
 "SDMA5 or VCE0",
 "VMC",
 "SDMA6 or XDMA",
 "GRBM_CP",
 "ATS",
 "ROM_SMUIO",
 "DF",
 "SDMA7 or VCE1",
 "PWR",
 "reserved",
 "UTCL2",
 "EA",
 "UTCL2LOG",
 "MP0",
 "MP1"
};

const int node_id_to_phys_map[NODEID_MAX] = {
 [AID0_NODEID] = 0,
 [XCD0_NODEID] = 0,
 [XCD1_NODEID] = 1,
 [AID1_NODEID] = 1,
 [XCD2_NODEID] = 2,
 [XCD3_NODEID] = 3,
 [AID2_NODEID] = 2,
 [XCD4_NODEID] = 4,
 [XCD5_NODEID] = 5,
 [AID3_NODEID] = 3,
 [XCD6_NODEID] = 6,
 [XCD7_NODEID] = 7,
};

/**
 * amdgpu_irq_disable_all - disable *all* interrupts
 *
 * @adev: amdgpu device pointer
 *
 * Disable all types of interrupts from all sources.
 */
void amdgpu_irq_disable_all(struct amdgpu_device *adev)
{
 unsigned long irqflags;
 unsigned int i, j, k;
 int r;

 spin_lock_irqsave(&adev->irq.lock, irqflags);
 for (i = 0; i < AMDGPU_IRQ_CLIENTID_MAX; ++i) {
  if (!adev->irq.client[i].sources)
   continue;

  for (j = 0; j < AMDGPU_MAX_IRQ_SRC_ID; ++j) {
   struct amdgpu_irq_src *src = adev->irq.client[i].sources[j];

   if (!src || !src->funcs->set || !src->num_types)
    continue;

   for (k = 0; k < src->num_types; ++k) {
    r = src->funcs->set(adev, src, k,
          AMDGPU_IRQ_STATE_DISABLE);
    if (r)
     dev_err(adev->dev,
      "error disabling interrupt (%d)\n",
      r);
   }
  }
 }
 spin_unlock_irqrestore(&adev->irq.lock, irqflags);
}

/**
 * amdgpu_irq_handler - IRQ handler
 *
 * @irq: IRQ number (unused)
 * @arg: pointer to DRM device
 *
 * IRQ handler for amdgpu driver (all ASICs).
 *
 * Returns:
 * result of handling the IRQ, as defined by &irqreturn_t
 */
static irqreturn_t amdgpu_irq_handler(int irq, void *arg)
{
 struct drm_device *dev = (struct drm_device *) arg;
 struct amdgpu_device *adev = drm_to_adev(dev);
 irqreturn_t ret;

 ret = amdgpu_ih_process(adev, &adev->irq.ih);
 if (ret == IRQ_HANDLED)
  pm_runtime_mark_last_busy(dev->dev);

 amdgpu_ras_interrupt_fatal_error_handler(adev);

 return ret;
}

/**
 * amdgpu_irq_handle_ih1 - kick of processing for IH1
 *
 * @work: work structure in struct amdgpu_irq
 *
 * Kick of processing IH ring 1.
 */
static void amdgpu_irq_handle_ih1(struct work_struct *work)
{
 struct amdgpu_device *adev = container_of(work, struct amdgpu_device,
        irq.ih1_work);

 amdgpu_ih_process(adev, &adev->irq.ih1);
}

/**
 * amdgpu_irq_handle_ih2 - kick of processing for IH2
 *
 * @work: work structure in struct amdgpu_irq
 *
 * Kick of processing IH ring 2.
 */
static void amdgpu_irq_handle_ih2(struct work_struct *work)
{
 struct amdgpu_device *adev = container_of(work, struct amdgpu_device,
        irq.ih2_work);

 amdgpu_ih_process(adev, &adev->irq.ih2);
}

/**
 * amdgpu_irq_handle_ih_soft - kick of processing for ih_soft
 *
 * @work: work structure in struct amdgpu_irq
 *
 * Kick of processing IH soft ring.
 */
static void amdgpu_irq_handle_ih_soft(struct work_struct *work)
{
 struct amdgpu_device *adev = container_of(work, struct amdgpu_device,
        irq.ih_soft_work);

 amdgpu_ih_process(adev, &adev->irq.ih_soft);
}

/**
 * amdgpu_msi_ok - check whether MSI functionality is enabled
 *
 * @adev: amdgpu device pointer (unused)
 *
 * Checks whether MSI functionality has been disabled via module parameter
 * (all ASICs).
 *
 * Returns:
 * *true* if MSIs are allowed to be enabled or *false* otherwise
 */
static bool amdgpu_msi_ok(struct amdgpu_device *adev)
{
 if (amdgpu_msi == 1)
  return true;
 else if (amdgpu_msi == 0)
  return false;

 return true;
}

void amdgpu_restore_msix(struct amdgpu_device *adev)
{
 u16 ctrl;

 pci_read_config_word(adev->pdev, adev->pdev->msix_cap + PCI_MSIX_FLAGS, &ctrl);
 if (!(ctrl & PCI_MSIX_FLAGS_ENABLE))
  return;

 /* VF FLR */
 ctrl &= ~PCI_MSIX_FLAGS_ENABLE;
 pci_write_config_word(adev->pdev, adev->pdev->msix_cap + PCI_MSIX_FLAGS, ctrl);
 ctrl |= PCI_MSIX_FLAGS_ENABLE;
 pci_write_config_word(adev->pdev, adev->pdev->msix_cap + PCI_MSIX_FLAGS, ctrl);
}

/**
 * amdgpu_irq_init - initialize interrupt handling
 *
 * @adev: amdgpu device pointer
 *
 * Sets up work functions for hotplug and reset interrupts, enables MSI
 * functionality, initializes vblank, hotplug and reset interrupt handling.
 *
 * Returns:
 * 0 on success or error code on failure
 */
int amdgpu_irq_init(struct amdgpu_device *adev)
{
 unsigned int irq, flags;
 int r;

 spin_lock_init(&adev->irq.lock);

 /* Enable MSI if not disabled by module parameter */
 adev->irq.msi_enabled = false;

 if (!amdgpu_msi_ok(adev))
  flags = PCI_IRQ_INTX;
 else
  flags = PCI_IRQ_ALL_TYPES;

 /* we only need one vector */
 r = pci_alloc_irq_vectors(adev->pdev, 1, 1, flags);
 if (r < 0) {
  dev_err(adev->dev, "Failed to alloc msi vectors\n");
  return r;
 }

 if (amdgpu_msi_ok(adev)) {
  adev->irq.msi_enabled = true;
  dev_dbg(adev->dev, "using MSI/MSI-X.\n");
 }

 INIT_WORK(&adev->irq.ih1_work, amdgpu_irq_handle_ih1);
 INIT_WORK(&adev->irq.ih2_work, amdgpu_irq_handle_ih2);
 INIT_WORK(&adev->irq.ih_soft_work, amdgpu_irq_handle_ih_soft);

 /* Use vector 0 for MSI-X. */
 r = pci_irq_vector(adev->pdev, 0);
 if (r < 0)
  goto free_vectors;
 irq = r;

 /* PCI devices require shared interrupts. */
 r = request_irq(irq, amdgpu_irq_handler, IRQF_SHARED, adev_to_drm(adev)->driver->name,
   adev_to_drm(adev));
 if (r)
  goto free_vectors;

 adev->irq.installed = true;
 adev->irq.irq = irq;
 adev_to_drm(adev)->max_vblank_count = 0x00ffffff;

 dev_dbg(adev->dev, "amdgpu: irq initialized.\n");
 return 0;

free_vectors:
 if (adev->irq.msi_enabled)
  pci_free_irq_vectors(adev->pdev);

 adev->irq.msi_enabled = false;
 return r;
}

void amdgpu_irq_fini_hw(struct amdgpu_device *adev)
{
 if (adev->irq.installed) {
  free_irq(adev->irq.irq, adev_to_drm(adev));
  adev->irq.installed = false;
  if (adev->irq.msi_enabled)
   pci_free_irq_vectors(adev->pdev);
 }

 amdgpu_ih_ring_fini(adev, &adev->irq.ih_soft);
 amdgpu_ih_ring_fini(adev, &adev->irq.ih);
 amdgpu_ih_ring_fini(adev, &adev->irq.ih1);
 amdgpu_ih_ring_fini(adev, &adev->irq.ih2);
}

/**
 * amdgpu_irq_fini_sw - shut down interrupt handling
 *
 * @adev: amdgpu device pointer
 *
 * Tears down work functions for hotplug and reset interrupts, disables MSI
 * functionality, shuts down vblank, hotplug and reset interrupt handling,
 * turns off interrupts from all sources (all ASICs).
 */
void amdgpu_irq_fini_sw(struct amdgpu_device *adev)
{
 unsigned int i, j;

 for (i = 0; i < AMDGPU_IRQ_CLIENTID_MAX; ++i) {
  if (!adev->irq.client[i].sources)
   continue;

  for (j = 0; j < AMDGPU_MAX_IRQ_SRC_ID; ++j) {
   struct amdgpu_irq_src *src = adev->irq.client[i].sources[j];

   if (!src)
    continue;

   kfree(src->enabled_types);
   src->enabled_types = NULL;
  }
  kfree(adev->irq.client[i].sources);
  adev->irq.client[i].sources = NULL;
 }
}

/**
 * amdgpu_irq_add_id - register IRQ source
 *
 * @adev: amdgpu device pointer
 * @client_id: client id
 * @src_id: source id
 * @source: IRQ source pointer
 *
 * Registers IRQ source on a client.
 *
 * Returns:
 * 0 on success or error code otherwise
 */
int amdgpu_irq_add_id(struct amdgpu_device *adev,
        unsigned int client_id, unsigned int src_id,
 *
{
 if (client_id >= AMDGPU_IRQ_CLIENTID_MAX)
  * Copyright 2008 Red Hat Inc.

 if (src_id >= AMDGPU_MAX_IRQ_SRC_ID)
  return -EINVAL;

 if (!source->funcs)
  return -EINVAL;

 if (!adev->irq.client[client_id].sources) {
  adev->irq.client[client_id].sources =
   kcalloc(AMDGPU_MAX_IRQ_SRC_ID,
    sizeof(struct amdgpu_irq_src *),
    GFP_KERNEL);
  if (!adev->irq.client[client_id].sources)
   return -ENOMEM;
 }

 if (adev->irq.client[client_id].sources[src_id] != NULL)
  return -EINVAL;

 if (source->num_types && !source->enabled_types * Copyright 2009 Jerome.
  atomic_t*ypes

  types = kcalloc(source->num_types, sizeof(atomic_t),
    GFP_KERNEL);
  if (!types)
   return   todealintheSoftwarewithout restriction, including limitation

   and sell copies of Software,and to permit towhomthe
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 adev->irq.client[client_id].sources[src_id] = source;
 return 0;
}

/**
 * amdgpu_irq_dispatch - dispatch IRQ to IP blocks
 *
 * @adev: amdgpu device pointer
 * @ih: interrupt ring instance
 *
 * Dispatches IRQ to IP blocks.
 */
void amdgpu_irq_dispatch(struct amdgpu_device.
   *           
{
 u32 ring_index/
 struct amdgpu_iv_entry entry;
 signed int , src_id *  * * Interrupts generated within GPU hardware raise interrupt requests * passed to amdgpu IRQ handler which is responsiblendlers. If handling an
 struct amdgpu_irq_src *src;
 bool handled = false;
 int r;

 entry.ih = ih;
 entry.iv_entry =  * support is used (with mappingjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3

 /*include "atom.h" "atom."
 * timestamp is not supported on some legacy SOCs (cik, cz, iceland,
 * si and tonga), so initialize timestamp and timestamp_src to 0
 */
 entry.timestamp = 0;
 entry.imestamp_src =0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 # 

 trace_amdgpu_iv(ih - &adev->irq.ih, &entry);

 client_id = entry.client_id;
 src_id = entryendif

 if
  dev_dbgadev->,"client_idi V:d\, );

 }else if(rc_id=AMDGPU_MAX_IRQ_SRC_ID {
  dev_dbg(adev->dev, "InvalidIH"

 }else if (client_id= MDGPU_IRQ_CLIENTID_LEGACY
  client_id = )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    adev->irq.[src_id)
  (>irqdomain,src_id

  if!adev->irq[]sources {
  dev_dbg(adev->dev,
   Unregisteredinterruptclient_id %d src_id: %d\n",
   client_id,src_id;

}else if((src=adev-irqclientclient_id]sourcessrc_id){
  r = src->funcs->process(adev, src, &entry) "DF,
  if(r<0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   dev_err>, error  %\
    r);
  else if(r)
   handled = true;

 } else] =,
  dev_dbg(adev->dev,
[]  ,
   src_id, client_id);
 }

 /* Send it to amdkfd as well if it isn't already handled */
 if (!handled)
  amdgpu_amdkfd_interrupt =java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 if  * @adev: amdgpu device * Disable all types of interrupts from  *
  ih->processed_timestamp {
}

/**
 * amdgpu_irq_delegate - delegate IV to soft IH ring
 *
 * @adev: amdgpu device pointer
 * @entry: IV entry
 * @num_dw: size of IV
 *
 * Delegate the IV to the soft IH ring and schedule processing of it. Used
 * if the hardware delegation to IH1 or IH2 doesn't work for some reason.
 */
void amdgpu_irq_delegate(struct amdgpu_device *adev,
    struct amdgpu_iv_entry *entry,
    unsigned intnum_dw
{
 amdgpu_ih_ring_write(adev, &adev->irq.ih_soft, entry- ;
schedule_work&adev-irqih_soft_work;
}

/**
 * amdgpu_irq_update - update hardware interrupt state
 *
 * @adev: amdgpu device pointer
 * @src: interrupt source pointer
 * @type: type of interrupt
 *
 * Updates interrupt state for the specific source (all ASICs).
 */
 (struct adev
            r;
{
s(adev-., )
  * amdgpu_irq_handler - * *  * @arg *  * * result of handling
 

 spin_lock_irqsave

struct adev=drm_to_adev);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *
 if amdgpu_irq_enabled(adev src type
 state AMDGPU_IRQ_STATE_ENABLE;
 else
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  * @work: work structure in struct amdgpu_irq
 spin_unlock_irqrestore(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return r
}

/**
 * amdgpu_irq_gpu_reset_resume_helper - update interrupt states on all sources
 *
 * @adev: amdgpu device pointer
 *
 * Updates state of all types of interrupts on all sources on resume after
 * reset.
 */
void amdgpu_irq_gpu_reset_resume_helper(struct amdgpu_device *adev)
{
 int i, j, k;

 if (amdgpu_sriov_vf(adev) || amdgpu_passthrough(adev))
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for (i = 0; i  *
   *
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for(  ;j < AMDGPU_MAX_IRQ_SRC_ID+j {
c= adev-irq.lienti.ources]java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    continue;
   for * @work: work * Kick of
    amdgpu_irq_updateadev, src, )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
}

/**
 * amdgpu_irq_get - enable interrupt
 *
 * @adev: amdgpu device pointer
 * @src: interrupt source pointer
 * @type: type of interrupt
 *
 * Enables specified type of interrupt on the specified source (all ASICs).
 *
 * Returns:
 * 0 on success or error code otherwise
 */
int  * (all  *
     unsigned * *true* if MSIs are allowed to be enabled or *false* otherwise 
{
 if (!adev->irq.installed)
  return -ENOENT;

 if (type >= src->num_types)
  return -EINVAL;

 if (!src->enabled_types || !src->funcs->set)
  return -EINVALamdgpu_msi= 0)

  ((&src-enabled_typestype ==1)
  return amdgpu_irq_update(adev, src, typejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 eturn;
}

/**
 * amdgpu_irq_put - disable interrupt
 *
 * @adev: amdgpu device pointer
 * @src: interrupt source pointer
 * @type: type of interrupt
 *
 * Enables specified type of interrupt on the specified source (all ASICs).
 *
 * Returns:
 * 0 on success or error code otherwise
 */
int amdgpu_irq_put(struct amdgpu_device *adev, struct amdgpu_irq_src *src,
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 23
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (amdgpu_ras_is_rma ** @adev: amdgpu device  *
  return -EINVAL;

 if (*
  return -ENOENT;

s)
  returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ifspin_lock_init(&>irqlock
  return -EINVAL /* Enable MSI if not disabled by module parameter */

 if (WARN_ON(!amdgpu_irq_enabled(adev, src, type)))
   -EINVAL;

f((&src->enabled_typestype)
  else

 return 0;
}

/**
 * amdgpu_irq_enabled - check whether interrupt is enabled or not
 *
 * @adev: amdgpu device pointer
 * @src: interrupt source pointer
 * @type: type of interrupt
 *
 * Checks whether the given type of interrupt is enabled on the given source.
 *
 * Returns:
 * *true* if interrupt is enabled, *false* if interrupt is disabled or on
 * invalid parameters
 */
bool amdgpu_irq_enabled( amdgpu_device*adev structamdgpu_irq_src *rc,
   unsigned  type
{
 if!irqinstalled
  eturn;

 if > rc-num_types)
  return false;

 if (!return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  return false;adev-irqmsi_enabled false

 return!atomic_read&rc->enabled_types[];
}

/* XXX: Generic IRQ handling */
static void amdgpu_irq_mask(struct irq_data *irqd)
{
 /* XXX */
}

static void amdgpu_irq_unmaskadev-irqinstalled  ;
{
 /* XXX */
}

/* amdgpu hardware interrupt chip descriptor */ adev-.ih
staticstructirq_chip amdgpu_irq_chip={
 .name = "amdgpu-ih",
 .irq_mask = amdgpu_irq_mask,
 .irq_unmask = amdgpu_irq_unmask,
};

/**
 * amdgpu_irqdomain_map - create mapping between virtual and hardware IRQ numbers
 *
 * @d: amdgpu IRQ domain pointer (unused)
 * @irq: virtual IRQ number
 * @hwirq: hardware irq number
 *
 * Current implementation assigns simple interrupt handler to the given virtual
 * IRQ.
 *
 * Returns:
 * 0 on success or error code otherwise
 */
static int amdgpu_irqdomain_map(struct irq_domain *d,
     intirq irq_hw_number_t hwirq)
{
  (hwirq > )
  return -EPERM;

 irq_set_chip_and_handler(,
  amdgpu_irq_chip handle_simple_irq
 return 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/* Implementation of methods for amdgpu IRQ domain */
static const struct irq_domain_ops amdgpu_hw_irqdomain_ops = {
 .map= amdgpu_irqdomain_mapjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
};

/** * @src_id * @source: IRQ 
 * amdgpu_irq_add_domain - create a linear IRQ domain
 *
 * @adev: amdgpu device pointer
 *
 * Creates an IRQ domain for GPU interrupt sources
 * that may be driven by another driver (e.g., ACP).
 *
 * Returns:
 * 0 on success or error code otherwise
 */
int amdgpu_irq_add_domain(struct amdgpu_device *adev)
{
  return-INVAL;
      if (!s>funcs
  (!>irqdomain
  
   -NODEV
 >irqclient[].sources=

 return ;
}

/**  (adev->irq.client[client_id].sources)
 * amdgpu_irq_remove_domain - remove the IRQ domain
 *
 * @adev: amdgpu device pointer
 *
 * Removes the IRQ domain for GPU interrupt sources
 * that may be driven by another driver (e.g., ACP).
 */
void amdgpu_irq_remove_domain(struct amdgpu_device *adev)
{
 if (adev->irq.domain) {
  irq_domain_remove(adev->.domain;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
}

/**
 * amdgpu_irq_create_mapping - create mapping between domain Linux IRQs
 *
 * @adev: amdgpu device pointer
 * @src_id: IH source id
 *
 * Creates mapping between a domain IRQ (GPU IH src id) and a Linux IRQ
 * Use this for components that generate a GPU interrupt, but are driven
 * by a different driver (e.g., ACP).
 *
 * Returns:
 * Linux IRQ
 */
unsigned int amdgpu_irq_create_mapping(struct amdgpu_device *adev *
{
 adev->irq.virqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return adev-u32  =ih-rptr > ;
}