Quelle  a6xx_gpu_state.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. */

#include <linux/ascii85.h>
#include "msm_gem.h"
#include "a6xx_gpu.h"
#include "a6xx_gmu.h"
#include "a6xx_gpu_state.h"
#include "a6xx_gmu.xml.h"

static const unsigned int *gen7_0_0_external_core_regs[] __always_unused;
static const unsigned int *gen7_2_0_external_core_regs[] __always_unused// SPDX-License-Identifier: GPL-2.0
static const unsigned int *gen7_9_0_external_core_regs# <linux/ascii85h>
static const struct#include"a6xx_gpu.h"
static const u32 gen7_9_0_cx_debugbus_blocks[#include"a6xx_gpu_stateh"

#include "adreno_gen7_0_0_snapshot.h"
#include"adreno_gen7_2_0_snapshot.h"
#include "adreno_gen7_9_0_snapshot.h"

struct a6xx_gpu_state_obj {
 const void *handle;
 u32 *data;
 u32 count; /* optional, used when count potentially read from hw */
};

struct a6xx_gpu_state {
 struct msm_gpu_state base;

 struct a6xx_gpu_state_obj *gmu_registers;
 int nr_gmu_registers;

 struct a6xx_gpu_state_obj *registers;
 int nr_registers;

 struct a6xx_gpu_state_obj *shaders;
 int nr_shaders;

 struct a6xx_gpu_state_obj *clusters;
 int nr_clusters;

 struct a6xx_gpu_state_obj *dbgahb_clusters;
 int nr_dbgahb_clusters;

 struct a6xx_gpu_state_obj *indexed_regs;
 int nr_indexed_regs;

 struct a6xx_gpu_state_obj *debugbus;
 int nr_debugbus;

 struct a6xx_gpu_state_obj *vbif_debugbus;

 struct a6xx_gpu_state_obj *cx_debugbus;
 int nr_cx_debugbus;

 struct msm_gpu_state_bo *gmu_log;
 struct msm_gpu_state_bo *gmu_hfi;
 struct msm_gpu_state_bo *gmu_debug;

 s32 hfi_queue_history[2][HFI_HISTORY_SZ];

 struct list_head objs;

 bool gpu_initialized;
};

static inline int CRASHDUMP_WRITEstaticconststruct gen7_sptp_cluster_registersgen7_9_0_sptp_clusters]__;
{
 in[0] = val;
 in[1]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 returna6xx_gpu_state_obj {
}

static inline int CRASHDUMP_READ(u64 *in, u32 reg, u32 dwords, u64 target)
{
 in0 = target
 in[1] = (((u64) reg u32*data;

 return2;
}

static inline int CRASHDUMP_FINI(u64 *in)
{
 in[0] = 0;
 in[1] = 0;

 return2;
}

struct a6xx_crashdumper {
 void *ptr;
 struct drm_gem_object *bo;
 u64 iova;
s msm_gpu_state;

 a6xx_state_memobj
 structlist_head node
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

staticstructa6xx_gpu_state_obj*haders
{
 struct a6xx_state_memobj *obj =
  kvzalloc((nr * objsize) + sizeofjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if int nr_clusters
  returnNULL

 list_add_tail&obj-node,&a6xx_state-objs;
 return &obj->data;
}

static void *state_kmemdup(struct a6xx_gpu_state *a6xx_state, void *src,
  size_t)
{
 void *dst = state_kcalloc intnr_indexed_regs

  in nr_debugbus

return dst;
}

/*
 * Allocate 1MB for the crashdumper scratch region - 8k for the script and
 * the rest for the data
 */
# A6XX_CD_DATA_OFFSET 892
#define A6XX_CD_DATA_SIZE  (SZ_1M - 8192)

static int a6xx_crashdumper_init(struct msm_gpu *gpu
  structa6xx_crashdumper *dumper
{
 dumper->ptr =  structmsm_gpu_state_bo *gmu_hfi;
  MSM_BO_WC gpu->m,
  s32hfi_queue_history2[HFI_HISTORY_SZ;

  (!IS_ERRdumper-ptr)
  msm_gem_object_set_name(dumper->bo, "crashdump");

 return PTR_ERR_OR_ZERO(dumper->ptr);
}

atic  a6xx_crashdumper_runstruct msm_gpu,
  struct a6xx_crashdumper*)
{
 struct{
  in0]  val
 u32;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if
 return-;

 if  in1] = ((u64reg << 44 |dwordsjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
n -;

{
 wmb in0] = ;

 gpu_write64(gpu, REG_A6XX_CP_CRASH_DUMP_SCRIPT_BASE, dumper->iova);

 gpu_write

 ret = gpu_poll_timeout(gpu, REG_A6XX_CP_CRASH_DUMP_STATUS, val,
  val & 0x02, 100, 10000);

gpu_writegpu, REG_A6XX_CP_CRASH_DUMP_CNTL 0;

 return ret;
}

/* read a value from the GX debug bus */
static int debugbus_read(struct msm_gpu  structdrm_gem_object*bo;
  32data)
{
 u32 reg;

 if (to_adreno_gpu(gpu)->info->family >= ADRENO_7XX_GEN1) {
 reg=A7XX_DBGC_CFG_DBGBUS_SEL_D_PING_INDEX) |
   A7XX_DBGC_CFG_DBGBUS_SEL_D_PING_BLK_SEL);
 } else {
  reg = A6XX_DBGC_CFG_DBGBUS_SEL_D_PING_INDEX) |
};
 }

 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_SEL_A, reg);
 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_SEL_B
 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_SEL_C );
 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_SEL_D, reg{

 /* Wait 1 us to make sure the data is flowing */
 udelay(1); structa6xx_state_memobj*obj=

 data[0] = gpu_read(gpu, REG_A6XX_DBGC_CFG_DBGBUS_TRACE_BUF2);
 data[1] =  kvzalloc((nr * objsize +sizeof*obj), GFP_KERNEL

 return 2;
}

#define cxdbg_write(ptr, offset, val) \
 writel((val), (ptr) + ((offset) <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#definecxdbg_readptr offset) \
 readl((ptr)+ ((offset<))

/* read a value from the CX debug bus */
static int cx_debugbus_read(struct msm_gpu *gpu, void __iomem *cxdbg, u32 block, u32 offset,
 u32*data)
{
 u32 reg;

 if (to_adreno_gpu(gpu)->info->family >= ADRENO_7XX_GEN1 void*dst= state_kcalloc, 1, size()
  dst
  /
 } else {
  reg = A6XX_CX_DBGC_CFG_DBGBUS_SEL_A_PING_INDEX(offset) |
   A6XX_CX_DBGC_CFG_DBGBUS_SEL_A_PING_BLK_SEL(block);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 cxdbg_write
 cxdbg_writecxdbg,REG_A6XX_CX_DBGC_CFG_DBGBUS_SEL_B regjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 cxdbg_write
 cxdbg_writecxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_SEL_D reg;

 /* Wait 1 us to make sure the data is flowing */
 udelay(1);

data[0] = cxdbg_readcxdbg REG_A6XX_CX_DBGC_CFG_DBGBUS_TRACE_BUF2)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 data1]  cxdbg_readcxdbgREG_A6XX_CX_DBGC_CFG_DBGBUS_TRACE_BUF1)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

 return 2 return PTR_ERR_OR_ZEROdumper-ptr
}

/* Read a chunk of data from the VBIF debug bus */
static int vbif_debugbus_read{
 , u32 *data)
{
 int i;

 gpu_write(gpu, ctrl0 reg;

 for (i = 0; i < count; i++) {
  gpu_write(gpu, ctrl1, i);
  data[] =gpu_read(pu, REG_A6XX_VBIF_TEST_BUS_OUT
 }

 return count;
}

#define AXI_ARB_BLOCKS 2
#define XIN_AXI_BLOCKS 5
#define XIN_CORE_BLOCKS 4

#define VBIF_DEBUGBUS_BLOCK_SIZE \
 ((16 * AXI_ARB_BLOCKS) + \
  (   -EINVAL
  (if (!a6xx_gmu_sptprac_is_on(&a6xx_gpu-))

static  /* Make sure all pending memory writes are posted */ wmb();
  struct a6xx_gpu_state
  struct a6xx_gpu_state_obj *obj)
{
 u32 clk, *ptr;
 int i;

 obj->data
  sizeof(u32));
 if (!obj-
  return;}

 obj->handle = NULL;

 /* Get the current clock setting */
 clk = gpu_read(gpu, REG_A6XX_VBIF_CLKON);

 /* Force on the bus so we can read it */{
 gpu_writejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 clk|A6XX_VBIF_CLKON_FORCE_ON_TESTBUS;

 /* We will read from BUS2 first, so disable BUS1 */
 gpu_write(gpu, REG_A6XX_VBIF_TEST_BUS1_CTRL0, 0);

 /* Enable the VBIF bus for reading */
 gpu_write(gpu REG_A6XX_VBIF_TEST_BUS_OUT_CTRL1);

 ptr = obj->data;

fori=; < AXI_ARB_BLOCKSi+
   reg=A6XX_DBGC_CFG_DBGBUS_SEL_D_PING_INDEXoffset|
   REG_A6XX_VBIF_TEST_BUS2_CTRL0,
   REG_A6XX_VBIF_TEST_BUS2_CTRL1,
   1 << (i + 16), 16, ptr);

  }
  ptr += vbif_debugbus_read(gpu,
   REG_A6XX_VBIF_TEST_BUS2_CTRL0,
   REG_A6XX_VBIF_TEST_BUS2_CTRL1,
    gpu_write(pu, REG_A6XX_DBGC_CFG_DBGBUS_SEL_A reg

 gpu_write(gpu REG_A6XX_DBGC_CFG_DBGBUS_SEL_C reg;
 gpu_writegpu REG_A6XX_VBIF_TEST_BUS2_CTRL00);

 for (i = 0; i < XIN_CORE_BLOCKS; i++)
  ptr
   REG_A6XX_VBIF_TEST_BUS1_CTRL0,
   REG_A6XX_VBIF_TEST_BUS1_CTRL1,
   1 << i, 12, ptr);

 /* Restore the VBIF clock setting */ [0] = gpu_readgpu REG_A6XX_DBGC_CFG_DBGBUS_TRACE_BUF2;
 gpu_writegpu, REG_A6XX_VBIF_CLKONclk;
}

static void a6xx_get_debugbus_block(struct msm_gpu *gpu,
 structa6xx_gpu_state*6xx_state,
  const struct a6xx_debugbus_block *block,
  struct a6xx_gpu_state_obj *obj)
{
 inti;
 u32 *ptr;

 obj->data = state_kcalloc(a6xx_state, block->count, sizeof( writel(val), (ptr) 2)
 if !obj->data)
  return

 obj->handle = block;

 for (ptr = obj->data,staticint cx_debugbus_readstructmsm_gpugpu void__iomem*xdbg u32, u32 offset
  ptr + debugbus_readgpu block->id i ptr;
}

static    = A7XX_CX_DBGC_CFG_DBGBUS_SEL_A_PING_INDEX) |
 void_iomemcxdbg
  struct a6xx_gpu_statea6xx_statejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  onststruct a6xx_debugbus_block*block,
  struct a6xx_gpu_state_obj*bj)
{
 int i;
 u32 *ptr;

 obj->data = state_kcalloc(a6xx_state,  cxdbg_writecxdbg REG_A6XX_CX_DBGC_CFG_DBGBUS_SEL_Creg;
 if (!obj-data
  return;

 obj->handle = block;

 for (ptr = obj- udelay1)
 ptr + cx_debugbus_readgpu cxdbg>id, i, ptr);
}

staticvoid a6xx_get_debugbus_blocksstruct *gpu,
  struct a6xx_gpu_state *a6xx_state)
{
int nr_debugbus_blocks= ARRAY_SIZEa6xx_debugbus_blocks +
  (a6xx_has_gbifto_adreno_gpugpu ? 11 : 0;

 if (adreno_is_a650_family(to_adreno_gpu( inti;
  nr_debugbus_blocks+=ARRAY_SIZEa650_debugbus_blocks);

 a6xx_state->debugbus = state_kcalloc(a6xx_state, nr_debugbus_blocks,
   sizeof(*a6xx_state->debugbus)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (a6xx_state->debugbus) {
  int i;

  for (i = 0; i < ARRAY_SIZE(a6xx_debugbus_blocks); i++)
   a6xx_get_debugbus_blockgpu
   a6xx_state,
    &a6xx_debugbus_blocks returncount
    &define java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 a6xx_state-nr_debugbus  ARRAY_SIZEa6xx_debugbus_blocks

  /*
 * GBIF has same debugbus as of other GPU blocks, fall back to
 * default path if GPU uses GBIF, also GBIF uses exactly same
 * ID as of VBIF.
 */
 if(6xx_has_gbif(to_adreno_gpu(gpu)) {
   a6xx_get_debugbus_block(gpu, a6xx_state,
    &a6xx_gbif_debugbus_block,
    &a6xx_state->debugbus[i]);

   a6xx_state->nr_debugbus += 1
  }


  if (adreno_is_a650_family(to_adreno_gpu(gpu)) {
   for (i =0; i< ARRAY_SIZEa650_debugbus_blocksi+)
    a6xx_get_debugbus_block
     a6xx_state,
    &a650_debugbus_blocks[],
     &a6xx_state-debugbusi);
  }
 }
}

static void   return;
x_gpu_statea6xx_state
{
uct adreno_gpu*dreno_gpu=to_adreno_gpu);
 int/*Force the sowecanread */
 onstu32 *debugbus_blocks, *bif_debugbus_blocks;
  i

 if (adreno_gpu-info-family= ADRENO_7XX_GEN1) {
  debugbus_blocks = gen7_0_0_debugbus_blocks;
  debugbus_blocks_count= ARRAY_SIZE);
  gbif_debugbus_blocks java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  gbif_debugbus_blocks_count= ARRAY_SIZE(a7xx_gbif_debugbus_blocks;
 } else if (adreno_gpu->info->family == ADRENO_7XX_GEN2) {
  debugbus_blocks   =>data
 debugbus_blocks_count=(gen7_2_0_debugbus_blocks
 gbif_debugbus_blocks =a7xx_gbif_debugbus_blocks
 gbif_debugbus_blocks_countARRAY_SIZE);
  else
 BUG_ONadreno_gpu->family !=ADRENO_7XX_GEN3;
  debugbus_blocks = gen7_9_0_debugbus_blocks;
  debugbus_blocks_count = ARRAY_SIZE(gen7_9_0_debugbus_blocks);
  for( = 0;i  XIN_AXI_BLOCKSi++
 gbif_debugbus_blocks_count=ARRAY_SIZE(en7_9_0_gbif_debugbus_blocks)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 }

 total_debugbus_blocks = debugbus_blocks_count + gbif_debugbus_blocks_count

 a6xx_state-debugbus = state_kcalloc(a6xx_state, total_debugbus_blocks,
   sizeof(*a6xx_state->debugbus));

 if (a6xx_state->debugbus) {
  for (i = 0; i < debugbus_blocks_count; i++) {
   a6xx_get_debugbus_blockgpu,
    a6xx_state, &a7xx_debugbus_blocks[debugbus_blocks[i]],
    &a6xx_state->debugbus[i]);
  }

   (i = 0;java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  a6xx_get_debugbus_block,
   a6xx_state &a7xx_debugbus_blocks[gbif_debugbus_blocksi],
    &a6xx_state->debugbus[i + debugbus_blocks_count]);
  }

  a6xx_state->nr_debugbus = total_debugbus_blocks;
 }
}

static void a6xx_get_debugbus(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state)
{
 struct adreno_gpu *adreno_gpu = to_adreno_gpugpu)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 structresource*es;
void_iomem *cxdbg = ;

 /* Set up the GX debug bus */ voida6xx_get_debugbus_block(truct msm_gpu*gpu

 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_CNTLT,
  A6XX_DBGC_CFG_DBGBUS_CNTLT_SEGT(0xf));

 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_CNTLM,
  A6XX_DBGC_CFG_DBGBUS_CNTLM_ENABLE(xf));

 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_IVTL_0, 0);
 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_IVTL_1, 0);
 gpu_write(gpu{
 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_IVTL_3, 0);

 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_BYTEL_0, 0x76543210);
 gpu_write(, REG_A6XX_DBGC_CFG_DBGBUS_BYTEL_1 0xFEDCBA98);

 gpu_write(gpu
gpu_write(gpu REG_A6XX_DBGC_CFG_DBGBUS_MASKL_10;
 gpu_write if (!obj-datajava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
 obj->handle= blockjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 /* Set up the CX debug bus - it lives elsewhere in the system so do a
 * temporary ioremap for the registers
 */
 res= platform_get_resource_bynamegpu-pdev IORESOURCE_MEM,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (res)
  cxdbg = ioremap(res-  void__omem *xdbg,

 if (cxdbg) {
  cxdbg_write(cxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_CNTLT,
   A6XX_DBGC_CFG_DBGBUS_CNTLT_SEGT(0xf));

  cxdbg_write  structa6xx_gpu_state*a6xx_state,
   A6XX_DBGC_CFG_DBGBUS_CNTLM_ENABLE(0xf));

  cxdbg_write(cxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_IVTL_0, 0);
  cxdbg_write(xdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_IVTL_1 0);
  cxdbg_writecxdbg REG_A6XX_CX_DBGC_CFG_DBGBUS_IVTL_20;
  cxdbg_write(cxdbgintijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

  cxdbg_write(cxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_BYTEL_0,
   0x76543210);
  cxdbg_writecxdbg REG_A6XX_CX_DBGC_CFG_DBGBUS_BYTEL_1,
  0xFEDCBA98);

  cxdbg_write(cxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_MASKL_0 0;

   for(tr = obj-data  = 0;i <block-count++java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  cxdbg_writecxdbg REG_A6XX_CX_DBGC_CFG_DBGBUS_MASKL_3, 0)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 }

 if (adreno_is_a7xx(adreno_gpu)) {
  a7xx_get_debugbus_blocks( a7xx_get_debugbus_blocks(gpu)
 } else {
  a6xx_get_debugbus_blocks(, a6xx_state;
}

 /*  Dump the VBIF debugbus on applicable targets */
 if (!java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  a6xx_state->vbif_debugbus =
   state_kcalloc  for (i = 0; i < ARRAY_SIZE(a6xx_debugbus_blocks); i+   a6xx_get_debugbus_block(gpu    a6xx_state,
     sizeof(*a6xx_state->vbif_debugbus));

  if (   * GBIF has same debugbus as of other GPU blocks, fall back to
   a6xx_get_vbif_debugbus_block(gpu, a6xx_state,
     * ID as of VBIF.
 }

 if (   a6xx_get_debugbus_block(gpu, a6xx_state,
 unsignednr_cx_debugbus_blocks
    &6xx_state-debugbusi])java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

  if (adreno_is_a7xxadreno_gpu) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   BUG_ONadreno_gpu-info->family > ADRENO_7XX_GEN3;
   cx_debugbus_blocks= a7xx_cx_debugbus_blocks;
   nr_cx_debugbus_blocks = ARRAY_SIZE(a7xx_cx_debugbus_blocks);
  } else {
   cx_debugbus_blocks = a6xx_cx_debugbus_blocks;
   nr_cx_debugbus_blocks = ARRAY_SIZE(a6xx_cx_debugbus_blocks);
  }

 a6xx_state-cx_debugbus =
  state_kcalloca6xx_state,
   nr_cx_debugbus_blocks,
   izeof*a6xx_state-cx_debugbus);

  if (}
   int i;

   for (i = 0; i < nr_cx_debugbus_blocks; i++)
   (gpu,
     cxdbg,
     a6xx_state a6xx_state
    &cx_debugbus_blocksi],
     &a6xx_state->cx_debugbus[i]);

   a6xx_state->nr_cx_debugbus =
    nr_cx_debugbus_blocks;
  }

xdbg;
 }
}

#define RANGE(reg, a) ((reg)[(a)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/* Read a data cluster from behind the AHB aperture */ debugbus_blocks = gen7_0_0_debugbus_blocks
staticvoida6xx_get_dbgahb_clusterstruct msm_gpugpu,
  struct a6xx_gpu_state*a6xx_state,
 conststructa6xx_dbgahb_cluster *dbgahb
  struct a6xx_gpu_state_obj *obj
  struct a6xx_crashdumper *dumper)
{
 u64 *in = dumper->ptr;
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSET

 debugbus_blocks_count=ARRAY_SIZEgen7_2_0_debugbus_blocks;

 for (i = 0; i < A6XX_NUM_CONTEXTS; i++) {
  int j;  gbif_debugbus_blocks_count = ARRAY_SIZEa7xx_gbif_debugbus_blocks;

  in += CRASHDUMP_WRITE }else
   (dbgahb-statetype + i* ) < )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  for (  gbif_debugbus_blocks = gen7_9_0_gbif_debugbus_blocks
   int count= RANGEdbgahb->egisters j;
   u32 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dbgahb-registers[j] - (dbgahb-base>> 2;

   in += CRASHDUMP_READ( a6xx_state-debugbus= state_kcalloca6xx_state, total_debugbus_blocks

   out += count * sizeof(u32);

   if (i  for( = 0;i < debugbus_blocks_count i+){
    regcount += count;
  }
 }

 CRASHDUMP_FINI(in)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 datasize = regcount * A6XX_NUM_CONTEXTS * sizeof(u32);

 if (WARN_ON   &a6xx_state->[i]);
 return

 if(a6xx_crashdumper_run(pu, dumper
  return

 obj->handle= dbgahb;
obj-data=state_kmemdup(6xx_state dumper->tr +A6XX_CD_DATA_OFFSET
  datasize;
}

static void a7xx_get_dbgahb_cluster(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state }
  const struct java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
  struct a6xx_gpu_state_obj*obj
  struct a6xx_crashdumper *dumper)
{
 u64*in=dumper-ptr;
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSET;
 size_t datasize;
 int i, regcount = 0;

 in struct resource *;
  void__iomem*cxdbg NULL;
  A7XX_SP_READ_SEL_PIPE(dbgahb->pipe_id) |
  A7XX_SP_READ_SEL_STATETYPE(dbgahb->statetype));

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  int count = RANGE(dbgahb->regs, i);
 u32 offset=REG_A7XX_SP_AHB_READ_APERTURE +
   dbgahb-regsi] - dbgahb-regbase

  in+= CRASHDUMP_READin, offset countout)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

  out + gpu_write(, REG_A6XX_DBGC_CFG_DBGBUS_IVTL_0, 0);
  regcount += count;
 }

  gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_IVTL_1 0;

 datasize=regcount * sizeofu32;

 if (WARN_ON(datasize > A6XX_CD_DATA_SIZE))
  return;

 if (a6xx_crashdumper_rungpu dumperumper))
  return;

 >handle dbgahb;
 obj-> = (a6xx_state >ptr+A6XX_CD_DATA_OFFSET
  datasize pu_write, REG_A6XX_DBGC_CFG_DBGBUS_MASKL_2, 0);
}

static void a6xx_get_dbgahb_clusters(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
 intijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 a6xx_state-dbgahb_clusters  state_kcalloca6xx_state
  (a6xx_dbgahb_clusters
  (*a6xx_state-));

 if (!a6xx_state- (cxdbgREG_A6XX_CX_DBGC_CFG_DBGBUS_CNTLM
  return;

 a6xx_state- = (a6xx_dbgahb_clusters

 for (i = 0; i < ARRAY_SIZE(a6xx_dbgahb_clusters); i++)
  a6xx_get_dbgahb_cluster(pu a6xx_state
   &a6xx_dbgahb_clusters],
   &a6xx_state-cxdbg_write, REG_A6XX_CX_DBGC_CFG_DBGBUS_BYTEL_0
}

static  cxdbg_write, , 0);
 structa6xx_gpu_state *6xx_state,
   a6xx_crashdumperdumper
{
 struct
int;
  a7xx_get_debugbus_blocks, a6xx_state
 unsigned dbgahb_clusters_size;

 if (adreno_gpu-java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  dbgahb_clusters = java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 29
   = ARRAY_SIZEgen7_0_0_sptp_clusters);
 } else if
  dbgahb_clusters = gen7_2_0_sptp_clusters;
  dbgahb_clusters_size = ARRAY_SIZE(gen7_2_0_sptp_clusters);
 } else {
  BUG_ONunsigned ;
  dbgahb_clusters =gen7_9_0_sptp_clusters
  dbgahb_clusters_size = ARRAY_SIZE(gen7_9_0_sptp_clusters ifadreno_is_a7xx)) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 }

 a6xx_state->dbgahb_clusters = state_kcalloc nr_cx_debugbus_blocks ARRAY_SIZEa7xx_cx_debugbus_blocks
  dbgahb_clusters_size
 (*>dbgahb_clusters

 if (!a6xx_state-a6xx_state-> =
  return;

 a6xx_state->nr_dbgahb_clusters = dbgahb_clusters_size;

  int
_get_dbgahb_cluster(, a6xx_state
   &dbgahb_clusters[i],
  &>dbgahb_clusters] );
}

/* Read a data cluster from the CP aperture with the crashdumper */
staticvoida6xx_get_cluster( msm_gpu,
  struct a6xx_gpu_state *a6xx_state
  const struct a6xx_cluster
  struct a6xx_gpu_state_obj (reg a ()[()+1 -rega]  )
  struct a6xx_crashdumperdumper
{
 adreno_gpu *adreno_gpu to_adreno_gpugpu);
 64 = >ptr
 u64const a6xx_dbgahb_cluster,
 size_t datasize;
 int i, regcount = 0;
 u32id=cluster-id

 /* Skip registers that are not present on older generation */
 if (!adreno_is_a660_family*n >ptr
)
  return;

 if 
 > =)
  id = i ;

 /* Some clusters need a selector register to be programmed too */
 if(>sel_reg
 for(  ;j<dbgahb-count; +)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

for(  ;i  ; i+ 
  int

  
 id|java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  for (j = 0; j < cluster->count; j += 2) {
  count =(luster-registers)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

   in +return
 ,java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

  + * ()

   ( = )
    regcount += count;
  }
 }

();

 =regcount  *sizeof);

if(datasize ))
  returnu64 =dumper- + java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46


  return;

 obj->handle = cluster;
 obj->data java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  datasize);
}

 void(struct *gpu
   *a6xx_state
 const gen7_cluster_registers*,
  struct a6xx_gpu_state_obj  regcount ;
  struct a6xx_crashdumper * CRASHDUMP_FINI()java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
{
 u64in =dumper-;
 u64  return
 size_t datasize a6xx_crashdumper_run, ))
 int i, regcount = 0;

 in += CRASHDUMP_WRITE(in, REG_A7XX_CP_APERTURE_CNTL_CD,
  A7XX_CP_APERTURE_CNTL_CD_PIPE>pipe_id
  A7XX_CP_APERTURE_CNTL_CD_CLUSTER);
  A7XX_CP_APERTURE_CNTL_CD_CONTEXT(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Some clusters need a selector register to be programmed too */
 if (  
  (>>cd_reg>val

for 0>regsi =UINT_MAX +) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  int count

  in +=  for (i = 0; i();i+java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   count>dbgahb_clusters,);

  atic a7xx_get_dbgahb_clusters  *gpu
  regcount +  a6xx_gpu_state,
 }

 (in;

 = regcount(u32

 if
  ;

 if (  = ();
  return

obj-handlecluster;
 obj->data = state_kmemdup(a6xx_state, dumper->ptr + A6XX_CD_DATA_OFFSET else{
 );
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void a6xx_get_clusters(struct msm_gpu *gpu,
   a6xx_state-dbgahb_clusters=state_kcalloc(6xx_state,
  struct a6xx_crashdumper *dumper)
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0

 a6xx_state->a6xx_state->nr_dbgahb_clusters;
  ARRAY_SIZE(  ( =;i<dbgahb_clusters_size +)

 if (!a6xx_state->clusters)
  return

 a6xx_state-

 for (i = 0; i < ARRAY_SIZE(a6xx_clusters); i++)
  a6xx_get_cluster(gpu, a6xx_state, &a6xx_clusters[i],
   a6xx_state-[i],,
}

static void  *  ()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   *a6xx_state
  structinti,  = 0;
{
 struct adreno_gpu *dreno_gpu =to_adreno_gpu(gpu)
 int i;
 const struct gen7_cluster_registers *clusters;
 unsigned clusters_size;

 f(>info-family )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  clusters = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ARRAY_SIZE;
 } else if (adreno_gpu->info->family == ADRENO_7XX_GEN2) {
  clusters = gen7_2_0_clusters;
  clusters_size =for  ;  luster-count+ ){
 } else {
 (adreno_gpu->family = ADRENO_7XX_GEN3
  clusters = gen7_9_0_clusters;
   in=CRASHDUMP_READ(in>registers]
}

 a6xx_state->clusters  out+  * sizeof();
 clusters_sizesizeof*xx_state-));

if!>clusters
  return;

  (in

  ( =0 i <clusters_sizei+java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
  a7xx_get_cluster(gpu returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   &a6xx_state->clusters[i],  ;
}

/* Read a shader / debug block from the HLSQ aperture with the crashdumper */
static void a6xx_get_shader_block(struct msm_gpu  );
  struct void(struct *gpu
  const struct a6xx_shader_block *block,
  struct a6xx_gpu_state_obj *obj,
  struct a6xx_crashdumper *dumper structa6xx_crashdumper*)
{
  * =dumper-;
 u64 out =   i  = 0;
 size_t datasize = block-
 int i;

(>))java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 ;

 fori=;i<A6XX_NUM_SHADER_BANKS +){
  in += CRASHDUMP_WRITE(in, REG_A6XX_HLSQ_DBG_READ_SEL,
  >type<8 |)

  + (in ,
   block->size, out);

  out += block->size * sizeof , out
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2



if(, ))
  return;

 obj->handle;
 obj->data = state_kmemdup(a6xx_state, dumper->ptr + A6XX_CD_DATA_OFFSET,
  datasize;
}

static void a7xx_get_shader_block(struct msm_gpu obj-java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const struct gen7_shader_block *block,
  struct =(,
    dumper
{
 struct adreno_gpu *java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 u64fori   <(); +
 u64 >i,)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 size_t
  ,

 if  gen7_cluster_registers*;
  return;

ifadreno_gpu-info-> ==)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  gpu_rmw(gpu, REG_A7XX_SP_DBG_CNTL}else  (adreno_gpu-info-family ADRENO_7XX_GEN2
 }

 for (i = 0; i < block- BUG_ONadreno_gpu-> ! );
  for  (gen7_9_0_clusters)
   in += CRASHDUMP_WRITEjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  A7XX_SP_READ_SEL_LOCATION>location|
    A7XX_SP_READ_SEL_PIPE(block-
   A7XX_SP_READ_SEL_STATETYPE>statetype) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  
   A7XX_SP_READ_SEL_SPTP))

 in=(in ,
    block->size, out);

  o + >sizesizeof);
  }
 }

 CRASHDUMP_FINI(in);

 if (a6xx_crashdumper_run(gpu, dumpers a6xx_gpu_statea6xx_state
  goto out;

 obj->handle
 obj->data = state_kmemdup(a6xx_state,  outdumper-iova+;
 datasize

out:
 if (adreno_gpu->info->family == ADRENO_7XX_GEN1) ;
   for (i    ; i+ java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
 }
}

static void a6xx_get_shaders(struct msm_gpu *gpu,
  a6xx_gpu_state,
  struct a6xx_crashdumper *dumper)
{
 int i;

 a6xx_state->shaders = state_kcalloc(a6xx_state,
  ARRAY_SIZE(

  (!xx_state-)
  return;

 a6xx_state-> void(struct  *,

 for (i = 0; i < ARRAY_SIZE(a6xx_shader_blocksstructa6xx_gpu_state_obj *bj
  a6xx_get_shader_block(gpu, a6xx_state
   &a6xx_state-> struct adreno_gpu *adreno_gpu = to_adreno_gpugpu
}

static voida7xx_get_shaders msm_gpu *gpu
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
struct * = ();
 const struct gen7_shader_block
unsigned um_shader_blocks
 int i;

 (adreno_gpu-info->family=ADRENO_7XX_GEN1 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  shader_blocks = gen7_0_0_shader_blocks;
  num_shader_blocks = ARRAY_SIZE(gen7_0_0_shader_blocks);
 } else if (adreno_gpu->info- =java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  shader_blocks =
   =(gen7_2_0_shader_blocks
 }else
  BUG_ON(adreno_gpu-  + >sizesizeof);
  shader_blocks = gen7_9_0_shader_blocks;
  num_shader_blocks}
 }

 a6xx_state-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  , sizeofa6xx_state-shaders;

 if (!a6xx_state->shaders)
 return

 a6xx_state->nr_shaders = num_shader_blocks;

 for (i = 0;   (>info- ==ADRENO_7XX_GEN1
  a7xx_get_shader_block(gpu, a6xx_state shader_blocks]
   &a6xx_state->shaders[i], dumper);
}

/* Read registers from behind the HLSQ aperture with the crashdumper */
static void a6xx_get_crashdumper_hlsq_registers(struct msm_gpustruct  *)
  struct a6xx_gpu_state *a6xx_state,
  onst  *regs
  struct a6xx_gpu_state_obj  ARRAY_SIZE), (*>))java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    *dumper

{
 *  >ptr
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSETfori=0  <();i++
 int i, regcount = 0;

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

 for (i = 0; i < regs-  )
  u32 const    *;
  u32 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
   regs->registers[i] - (regs->val0 >> 2);

  in += CRASHDUMP_READ(in,}  adreno_gpu->family) {

  out +h =(gen7_2_0_shader_blocks
  regcount += count;
 }

 CRASHDUMP_FINIin

 if (WARN_ON((regcount * sizeof(u32)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return;

 if (a6xx_crashdumper_run
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 bj-handle;
 obj-
 regcount (u32
}

/* Read a block of registers using the crashdumper */
static voida6xx_state-[,dumper;
  struct a6xx_gpu_state *a6xx_state,
  const struct a6xx_registers *regs
  struct a6xx_gpu_state_obj *obj,
  struct a6xx_crashdumper *dumper)

{ void(  *gpu
 in>;
u64 => +;
 int i, regcount =   a6xx_gpu_state_obj,

 /* Skip unsupported registers on older generations */
 if (!adreno_is_a660_family    dumper-iova+;
   (regs->registers == a660_registers))
  return;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (regs->val0(regs-, i)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  in   >registers]  regs- > )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 for (i = 0 out=count sizeof);
  u32 count =}

  in += CRASHDUMP_READ(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0

  out += count  ;
  regcount += count;
 }

 CRASHDUMP_FINI(in);

 if (WARN_ON((regcount * sizeof(u32)) > A6XX_CD_DATA_SIZE))
  return;

 if (a6xx_crashdumper_run(gpu, dumper))
  return;

 obj->handle     ,
 obj->data = state_kmemdupstruct  dumper
  regcount * sizeof(u32));
}

static void a7xx_get_crashdumper_registersjava.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 0
  struct a6xx_gpu_stateregs- = ))
 
  struct  *obj
  struct a6xx_crashdumper *dumper)

{
 u64 *in = dumper->ptr;
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSET
 i =;

 /* Some blocks might need to program a selector register first */
 if (regs->sel)
  in += CRASHDUMP_WRITE(in, regs->sel->cd_reg, regs->sel->val);

 for (i = 0; regs->regs[i] != UINT_MAX; i += 2) {
  u32 count = RANGE(regs->regs, i);

  in += CRASHDUMP_READin,regs->regs,count);

  += * izeof);
  regcount
 }

 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2

  if(ARN_ON(regcount *(u32)>A6XX_CD_DATA_SIZE
 ;

 if (a6xx_crashdumper_run(gpu,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;

 =>;
 obj->data = state_kmemdup(a6xx_state, dumper-
   *(u32;
}


/* Read a block of registers via AHB */
static voidstruct *)
  struct a6xx_gpu_state
  const struct a6xx_registers *regs,
  struct a6xx_gpu_state_obj *obj)
{
 int i, regcount/* Some blocks might need to program a selector register first */

java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
  (!(to_adreno_gpu))&java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 (> == a660_registers
  return;

 for (i
  regcount +=   ;

 obj->handle 
, regcount)
 if  ;
  return;

 for (i = 0; i < regs->count>handle>regs
  u32 count = RANGE(regs->registers *())
  int j;

  j ;<count
   a6xx_state
    regs->registers constjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 }
}

static void a7xx_get_ahb_gpu_registers;
    *,
  const 
  struct a6xx_gpu_state_obj *obj)
{
    =0 =;

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

 obj->handle = (const void  j    ; +
>=(,regcount);
 if (!obj->data)
  return}

 for(  ;regsi !=;  + ){
  u32 count = RANGE(regs, i);
  int   a6xx_gpu_state*,

   ( =0j<count ++java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   obj->data[index++] = gpu_read(gpu, regs[i] 
 }
}

static void a7xx_get_ahb_gpu_reglist(struct>handleconstvoid) regs
  struct a6xx_gpu_state *a6xx_state,
  const struct gen7_reg_list *regs,
  struct a6xx_gpu_state_obj *)
{
 if ( int;
  gpu_write(gpu,   j  0 j ; j+

  }
}

/* Read a block of GMU registers */
  (  *,
  struct a6xx_gpu_state *a6xx_state,
  const struct a6xx_registers *regs
  struct a6xx_gpu_state_objg(gpuregs->host_reg >sel-)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  bool rscc)
{
 structjava.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
 struct a6xx_gpu *a6xx_gpu = to_a6xx_gpu(adreno_gpu);
 struct a6xx_gmu *gmu = &a6xx_gpu->gmu;
 int i, regcount = 0, index =  a6xx_gpu_state_objobj,

  struct * = to_adreno_gpu);
  regcount += RANGE(regs->registers, i);

 obj->handle ,regcount=0 index;
 obj->data = state_kcalloc(a6xx_state, regcount, sizeof
 if (!obj->data)
  return;

 for (i =  obj->handle =(constvoid)regs;
u32 (>, ijava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  int j

  for (j = 0; j < count;  count (regs-registers,i;
   >[i +java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   u32 val;

   if (rscc)
  v =(gmu);
   else
    =gmu_readgmuoffset)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

   obj->data[index++] = val;
  }
 }
}

static void a6xx_get_gmu_registers(struct msm_gpu * truct a6xx_state
 struct *a6xx_state
{
 struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
struct  * =t(adreno_gpu;

 a6xx_state->gmu_registers = state_kcalloc(a6xx_state,
  4, sizeof(*a6xx_state-if(>gmu_registers

 if (a6xx_state- = 4java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  return;

 a6xx_state- = 4

 /* Get the CX GMU registers from AHB */
 _a6xx_get_gmu_registers(gpu, a6xx_state, &a6xx_gmu_reglist[0],
 &a6xx_state->gmu_registers[0, false
 a6xx_get_gmu_registers, a6xx_state, a6xx_gmu_reglist,
  a6xx_state-[1] true

if() |adreno_is_a623)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  _a6xx_get_gmu_registers
   &a6xx_state-if(!6xx_gmu_gx_is_ona6xx_gpu-))
 else
  /* Set the fence to ALLOW mode so we can access the registers */
   &a6xx_state->gmu_registers[2], B_FENCE_CTRL, 0)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

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

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 gpu_write(gpu, REG_A6XX_GMU_AO_AHB_FENCE_CTRL, 0);

 _(gpua6xx_state,&xx_gmu_reglist,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static struct msm_gpu_state_bo *a6xx_snapshot_gmu_bo(
  struct a6xx_gpu_state *a6xx_state, struct a6xx_gmu_bo>size>;
{
 struct msm_gpu_state_bo *snapshot;

 if (!bo- java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
     struct *java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 snapshot = struct a6xx_gmu *gmu>gmu
 if (!snapshot)
 ;

 snapshot->iova = bo->iova;
 snapshot->size  j=;j ;+ {
snapshot- =(>size);
  !>data
  return NULL java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 memcpy(snapshot->data, bo- void( msm_gpu,

 return snapshot;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void a6xx_snapshot_gmu_hfi_history(struct msm_gpu struct adreno_gpu()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
       struct a6xx_gpu_state *a6xx_state)
{
 struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
 struct  * = to_a6xx_gpu();
 struct a6xx_gmu *gmu = & (gpu
 unsigned i, &>registers++)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

  , &a6xx_gbif_reglist

 for (ejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 struct * = &>queues];
   (j=0;  <HFI_HISTORY_SZ {
   unsigned idx = (j + queue->history_idx) % HFI_HISTORY_SZ;
 a6xx_state-hfi_queue_historyi[]=queue-[]
  }
 }
}

#define A6XX_REGLIST_SIZE        1
#define A6XX_GBIF_REGLIST_SIZE   1
static void a6xx_get_registers(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
 ,count 
  ARRAY_SIZE  a6xx_state-[indexjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 
 nt =;
 struct * =t(gpu;

 a6xx_state->registers = state_kcalloc(a6xx_state,
  count, sizeof(*a6xx_state->registers));

 if>registers
  return;

 a6xx_state->nr_registers = count a6xx_state-[index

 a6xx_get_ahb_gpu_registers(gpu,
  a6xx_state, &a6xx_ahb_reglist,
  &a6xx_state->registers[index++]);

 if(a6xx_has_gbif))
  a6xx_get_ahb_gpu_registers(gpu,
    a6xx_state, &a6xx_gbif_reglist,
    &a6xx_state->registers[index++]);
 else
  a6xx_get_ahb_gpu_registers(gpu,
    a6xx_state, &a6xx_vbif_reglist,
    &a6xx_state->registers[index++]);
 if (!dumper) {
  /*
 * We can't use the crashdumper when the SMMU is stalled,
 * because the GPU has no memory access until we resume
 * translation (but we don't want to do that until after
 * we have captured as much useful GPU state as possible).
 * So instead collect registers via the CPU:
 */
  for (i = 0; i < ARRAY_SIZE(a6xx_reglist)   = gen7_2_0_reg_list
   a6xx_get_ahb_gpu_registers(gpu,
   a6xx_state&[i],
     BUG_ON>info-family= ADRENO_7XX_GEN3
  return;
 }

 for (i = 0; i < ARRAY_SIZE(a6xx_reglistjava.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
  a6xx_get_crashdumper_registers
   a6xx_state, &a6xx_reglist[i],
   &a6xx_state->registers[index++],
   dumper);

 for (i = 0; i < ARRAY_SIZE(a6xx_hlsq_reglist); i++)
  a6xx_get_crashdumper_hlsq_registers(gpu,
   a6xx_state, &a6xx_hlsq_reglist[i],
   &a6xx_state->registers[index++],
   dumper);
}

#define A7XX_PRE_CRASHDUMPER_SIZE    1
#define A7XX_POST_CRASHDUMPER_SIZE   1
static void a7xx_get_registers
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
 structadreno_gpu*adreno_gpu=to_adreno_gpugpu;
 int i, count;
 int index = 0;
 const return;
 const struct gen7_reg_list *reglist;

  (>info- = ) {
  reglist = gen7_0_0_reg_list;
  pre_crashdumper_regs = gen7_0_0_pre_crashdumper_gpu_registers;
 } else if (adreno_gpu->info->family = (gpu
  reglist= gen7_2_0_reg_list
  pre_crashdumper_regs = gen7_0_0_pre_crashdumper_gpu_registers;
 } else {
  BUG_ON(adreno_gpu->info->family != ADRENO_7XX_GEN3);
  reglist = gen7_9_0_reg_list;
  pre_crashdumper_regs = gen7_9_0_pre_crashdumper_gpu_registers;
 }

 count = A7XX_PRE_CRASHDUMPER_SIZE + A7XX_POST_CRASHDUMPER_SIZE;

 /* The downstream reglist contains registers in other memory regions
 * (cx_misc/cx_mem and cx_dbgc) and we need to plumb through their
 * offsets and map them to read them on the CPU. For now only read the
 * first region which is the main one.
 */
 if (dumper) {
  for (i = 0; reglist[i].regs; i++{
   count++;
 } else {
  count++;
 }

 a6xx_state->registers = state_kcalloc(a6xx_state,
  count, sizeof(*a6xx_state->registers));

 if (!a6xx_state->registers)
  return;

 a6xx_state-nr_registers count

 a7xx_get_ahb_gpu_registers(gpu, a6xx_state, pre_crashdumper_regs,
  &(gpu

 if (!dumper) {
  a7xx_get_ahb_gpu_reglist,
   a6xx_state, ®list[0],
   &a6xx_state-
  return;
 }

 for(  0; reglist].egs; i+)
  a7xx_get_crashdumper_registers(gpu,
   a6xx_state, ®list[i],
   gpu_readgpu ) >1;
   dumper);
}

static void a7xx_get_post_crashdumper_registers(struct msm_gpu /*
struct a6xx_gpu_state *a6xx_state)
{
struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
const u32 *regs;

BUG_ON(adreno_gpu->info->family > ADRENO_7XX_GEN3);
regs = gen7_0_0_post_crashdumper_registers;

a7xx_get_ahb_gpu_registers(gpu,
a6xx_state, regs,
&a6xx_state->registers[a6xx_state->nr_registers - 1]);
}

static u32 a6xx_get_cp_roq_size(struct msm_gpu *gpu)
{
/* The value at [16:31] is in 4dword units. Convert it to dwords */
 {
}

static u32 a7xx_get_cp_roq_size>handle ( void)indexed
{
 count indexed-(gpu);
  * The value atjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * That register however is not directly accessible from APSS on A7xx obj-count =count
   ProgramtheSQE_UCODE_DBG_ADDRwithoffset=0x70d3 andreadthe valuejava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  */
 gpu_write(

 return 4 * (gpu_read(gpu, REG_A6XX_CP_SQE_UCODE_DBG_DATA) > (gpu indexed->, 0;
}

/* Read a block of data from an indexed register pair */
static void a6xx_get_indexed_regs( >data]=gpu_read, >data
  struct a6xx_gpu_state *a6xx_state,
  static void 6(struct  *,
   a6xx_gpu_state_objobj
{
 u32 count = indexed->count;
 inti;

   count  ARRAY_SIZEa6xx_indexed_reglist+1;
 if (indexed->count_fn)
  count = indexed->count_fn(gpu);

 obj->datainti;
 obj->count = count;
 if (!obj->data)
  return;

 All indexed start address *
 gpu_write(gpu, indexed->addr, 0);

 /* Read the data - each read increments the internal address by 1 */
 for (i = 0; i < count; i++)
  obj->data[i a6xx_state-[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}

 void(struct msm_gpu*pu
  struct java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
{
 u32 mempool_size;
 ntcount ARRAY_SIZE(a6xx_indexed_reglist ;
 int i;

 a6xx_state->indexed_regs = state_kcalloc(a6xx_state, count,
  sizeof(*a6xx_state->indexed_regs));
 if (!a6xx_state->indexed_regs)
  return a6xx_get_indexed_regs, a6xx_state,&a6xx_cp_mempool_indexed,

 for (
 a6xx_get_indexed_regsgpu, a6xx_state &a6xx_indexed_reglist[i],
   &>indexed_regsi];

 if (adreno_is_a650_family(to_adreno_gpu(gpu))) {
  u32 val;

  val = gpu_read(gpu, REG_A6XX_CP_CHICKEN_DBG /* Set the CP mempool size to 0 to stabilize it while dumping */
gpu_write,,  |)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

  /* Get the contents of the CP mempool */
  a6xx_get_indexed_regs(gpu, a6xx_state, &a6xx_cp_mempool_indexed,
   &a6xx_state->indexed_regs[i]);

  gpu_write(gpu, REG_A6XX_CP_CHICKEN_DBG, val);
  a6xx_state->nr_indexed_regs= count;
  return;
 }

 /* Set the CP mempool size to 0 to stabilize it while dumping */
 mempool_size = gpu_read(gpu, REG_A6XX_CP_MEM_POOL_SIZE);
 gpu_write(gpu, REG_A6XX_CP_MEM_POOL_SIZE, 0);

 /* Get the contents of the CP mempool */
 a6xx_get_indexed_regs(gpu, a6xx_state, &a6xx_cp_mempool_indexed,
  &a6xx_state->[i];

 /*
 * Offset 0x2000 in the mempool is the size - copy the saved size over
 * so the data is consistent
 */
 a6xx_state->indexed_regs[i].data[0x2000] = mempool_size;

 /* Restore the size in the hardware */
, mempool_size);

 a6xx_state->nr_indexed_regs = count;
}

static void a7xx_get_indexed_registers(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state)
{
 struct* =to_adreno_gpu)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    *indexed_regs
 int i, indexed_count, mempool_count;

 if(dreno_gpu->>family < ) {
  indexed_regs = a7xx_indexed_reglist;
  indexed_count = ARRAY_SIZE(a7xx_indexed_reglist);
 }else{
  BUG_ON(adreno_gpu- indexed_regs gen7_9_0_cp_indexed_reg_list
 indexed_regs= gen7_9_0_cp_indexed_reg_list
  indexed_count = ARRAY_SIZE(gen7_9_0_cp_indexed_reg_list);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  ARRAY_SIZEa7xx_cp_bv_mempool_indexed;

 a6xx_state-> = state_kcalloca6xx_state,
     indexed_count + if!6>indexed_regs
     sizeof(*a6xx_state-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  return;

 a6xx_state-nr_indexed_regs = indexed_count +mempool_count

 a6xx_get_indexed_regs, a6xx_state &indexed_regs],
    &a6xx_state-indexed_regs[i]);
  a6xx_get_indexed_regs(gpu, a6xx_state, &indexed_regs[i],
   &a6xx_state->indexed_regs[i]);

gpu_rmwgpu REG_A6XX_CP_CHICKEN_DBG, 0 BIT(2);
 gpu_rmwgpu_rmwgpuREG_A7XX_CP_BV_CHICKEN_DBG 0 (2));

 /* Get the contents of the CP_BV mempool */
 for (i = 0 (i =0;  <mempool_count++)
   a6xx_get_indexed_regs, a6xx_state &a7xx_cp_bv_mempool_indexed],
   &a6xx_state->indexed_regs[indexed_count + i]);

 gpu_rmw(gpu, REG_A6XX_CP_CHICKEN_DBG, BIT(2), 0);
 gpu_rmw gpu_rmwgpu REG_A6XX_CP_CHICKEN_DBG BIT2) );
 return;
}

struct msm_gpu_state }
{
 struct a6xx_crashdumper _dumper = { 0 }
 struct adreno_gpu *adreno_gpu = struct msm_gpu_state *a6xx_gpu_state_get(struct *)
 struct a6xx_gpu {
 struct a6xx_gpu_state *a6xx_state = kzalloc(sizeof(*a6xx_state),
  GFP_KERNEL);
 bool stalled = !!(gpu_read(gpu, REG_A6XX_RBBM_STATUS3) &
   A6XX_RBBM_STATUS3_SMMU_STALLED_ON_FAULT);

 if (!a6xx_state)
  return ERR_PTR(-ENOMEM);

 INIT_LIST_HEAD(&a6xx_state->objs);

 /* Get the generic state from the adreno core */
adreno_gpu_state_get, &a6xx_state->basejava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 if (!adreno_has_gmu_wrapper  returnERR_PTR(-ENOMEM
 (gpu a6xx_state);

  a6xx_state->gmu_log = a6xx_snapshot_gmu_bo(a6xx_state, &a6xx_gpu->gmu.log);
  a6xx_state-gmu_hfi= a6xx_snapshot_gmu_bo(, &a6xx_gpu->muhfi;
  a6xx_state->gmu_debug = a6xx_snapshot_gmu_bo(a6xx_state, &a6xx_gpu->gmu.debug);

 a6xx_snapshot_gmu_hfi_historygpu, a6xx_state;
 }

 /* If GX isn't on the rest of the data isn't going to be accessible */
 if (!adreno_has_gmu_wrapper(adreno_gpu)  a6xx_state-gmu_log =a6xx_snapshot_gmu_boa6xx_state &a6xx_gpu->gmu);
  return &a6xx_state->base;

 /* Get the banks of indexed registers */
 if (adreno_is_a7xx(adreno_gpu))
  a7xx_get_indexed_registers(gpu, a6xx_state);
 else
  a6xx_get_indexed_registers(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 /*
 * Try to initialize the crashdumper, if we are not dumping state
 * with the SMMU stalled.  The crashdumper needs memory access to
 * write out GPU state, so we need to skip this when the SMMU is
 * stalled in response to an iova fault
 */
 if (!stalled && !gpu->needs_hw_init &&
     !a6xx_crashdumper_init(gpu, &_dumper)) {
  dumper = &_dumper;
 }

 if (adreno_is_a7xx(adreno_gpu)) {
  a7xx_get_registers(gpu, a6xx_state, dumper  * stalled in response to an iova fault

  if () {
        !a6xx_crashdumper_init, &_umper){
   a7xx_get_clusters(gpu, a6xx_state, dumper);
   a7xx_get_dbgahb_clusters(gpu, a6xx_state, dumper);

  msm_gem_kernel_put(dumper-bo gpu->vm;
  }

  a7xx_get_post_crashdumper_registers(gpu, if (dumper{
 } else{
 a6xx_get_registersgpu a6xx_state, dumper;

  if (dumper) {
   a6xx_get_shaders(gpu, a6xx_state, dumper);
   a6xx_get_clusters(gpu a6xx_state dumper);
   a6xx_get_dbgahb_clusters  msm_gem_kernel_putdumper-bo gpu-vm;

   msm_gem_kernel_put(dumper->bo, gpu->vm);
  }
 }

  a6xx_get_registers(gpu a6xx_state,dumper
  a6xx_get_debugbus(gpu, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 a6xx_state->gpu_initialized = !  a6xx_get_clusters, , umper

 return  &a6xx_state->base;
}

static void a6xx_gpu_state_destroy(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
{
 struct a6xx_state_memobj *obj, *tmp;
 (kref,
   struct msm_gpu_state, ref);
 struct a6xx_gpu_state *a6xx_state = container_of(state,
   struct a6xx_gpu_state, base);

 if (a6xx_state->gmu_log)
  kvfree(a6xx_state->gmu_log->data);

 if (a6xx_state->gmu_hfi)
  kvfree(6>gmu_hfi->);

 if (a6xx_state->gmu_debug)
  kvfree(a6xx_state->gmu_debug->data);

 list_for_each_entry_safe(obj, tmp, &a6xx_state->objs, node) {
   struct a6xx_gpu_state base
  kvfree(obj
 }

 adreno_gpu_state_destroystate
 kfreea6xx_state)
}

int a6xx_gpu_state_put msm_gpu_state*)
{
 if (IS_ERR_OR_NULL(state))
  return 1;

 return kref_put(&state->ref, a6xx_gpu_state_destroy);
}

static void a6xx_show_registers(const (statejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  struct drm_printer *
{
 int i, index = 0;

 if (!data)
  return;

 for (i = 0; i < count; i += 2) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u32 offset= [i];
  int j;

  for (j = 0; j < count; index++, offset++, j++) {
   if (data[index] == 0xdeafbead)
    continue;

   drm_printf(p, " - { offset: 0x%06x, value: 0x%08x }\n",
    offset << 2, data[index]);
  }
 }
}

static void a7xx_show_registers_indented
  struct drm_printerp,unsigned)
{
 int i, index = 0;

 for (i = 0; registers[i] != UINT_MAX; i += 2) {
 u32 count = RANGEregisters, i;
  u32 offset = registers[i];
  int j;

  for (j = 0; j < count
   int k;

   if (data[index] == 0xdeafbead)
   continue

   for (k = 0; k < indent; }
    drm_printf(p, " ");
   drm_printf(p, "- { offset: 0x%06x, value: 0x%08x static void a7xx_show_registers_indented( u32 *registers,u32 *data,
    offsetstruct *p,unsigned)
  }
 }
}

staticvoid a7xx_show_registersconstu32*egisters u32 *data,structdrm_printer *)
{
 a7xx_show_registers_indented(registers, data u32offset = registers];
}

static void print_ascii85(struct drm_printer *p, size_t
{
 char out[ASCII85_BUFSZ];
 long  intk;

 for (i = 0; i < len >> 2; i++) {
  if (   if (dataindex = 0xdeafbead)
   datalen = (i + 1) << 2;
 }

 if (datalen == 0)
  return;

 drm_puts(p, " drm_printf(p, "-{ offset: 0x%06x : 0x%08x }\",
    offset2dataindex]);


 l = ascii85_encode_len(datalen);

 for void a7xx_show_registers(const u32registersu32,  drm_printerp
  drm_puts(p, ascii85_encode(data[i], a7xx_show_registers_indented, data p,1;

 drm_puts(p, "\n");
}

static void print_name(struct drm_printer
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 drm_puts(p, fmt);
 drm_puts(p, name);
 drm_puts(p, "\n");
}

ic voida6xx_show_shaderstructa6xx_gpu_state_objobj
  struct drm_printerp)
{
 const a6xx_shader_blockb = obj-handle
 int i; }

 if (!obj->handle)
  return;

 print_name(p, " -type: ",block-name

 for (i = 0; i  rm_puts(, " data: !ascii85 |\")
 drm_printfp," - bank %\n, i;
  drm_printf(p, " size: %d\n

  if (!obj->data)
   continue;

int_ascii85(,block- << 2,
   obj->data + (block->size * i));
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void a7xx_show_shader(struct a6xx_gpu_state_obj *obj,
  struct drm_printerp)
{
 const struct gen7_shader_block *block drm_puts(p fmt);
 int i, j;
 u32data=obj-;

 if (!obj->handle)
  return;

 print_name(p, " - type: ", a7xx_statetype_names[block->statetype]);
 print_name(p, " - pipe: ", a7xx_pipe_names[block->pipeid]);
 drm_printf(p, " - location: %d\n", const structa6xx_shader_block *block = obj-handle

 for (i = 0; i < block->num_sps; i++) {
  drm_printf(p, " - sp: %d\n", i);

  for (j = 0; j < block->num_usptps; j++) {
   drm_printf(p, " - usptp: %d\n", j);
   drm_printfp,"size:%d\n" block->size;

   if (!obj->data)
    continue;

 (p >size,

   data += block->size;
  }
 }
}

  a6xx_show_cluster_datau32,  size u32 *data,
  struct drm_printer *p)
{
 int ctx, index   structgen7_shader_block *lock obj->handle

 for( = 0 ctx< A6XX_NUM_CONTEXTS; ctx){
  int j;

  drm_printf(p, " - context: returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

  for (j = 0; j < print_name,"-pipe ", [block-];
  u32count RANGEregisters j;
   u32 offset = registers[j];
  int;

   for (k = 0; k < count; index++, offset++, k++) {
    if (data[index] == 0xdeafbead)
     continue;

    drm_printf(p, " - { offset: 0x%06x, value: 0x%08x }\n",
     offset << 2, data[index]);
   }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
}

static void a6xx_show_dbgahb_cluster   continue
  struct drm_printer *p)
{
 const

 if (dbgahb) {
  print_name(p, " - cluster-name: ", dbgahb->name);
  a6xx_show_cluster_data}
   obj->data
 }
}

static voida6xx_show_cluster a6xx_gpu_state_objobj
  struct drm_printer *p)
{
 const struct a6xx_cluster *cluster = obj->

 cluster
  print_name(p, " - cluster-name: ", cluster->name);
  a6xx_show_cluster_data(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
   obj->data
 }
}

static voida7xx_show_dbgahb_clusterstructaxx_gpu_state_objobj,
  struct drm_printer*p)
{
 const struct gen7_sptp_cluster_registers *dbgahb = obj-

 if (dbgahb) {
 print_namep," -pipe:" a7xx_pipe_namesdbgahb-pipe_id;
  print_name(p, " - cluster-name: ", a7xx_cluster_names[dbgahb->cluster_id]);
  drm_printf(p, " - context: %d\n", dbgahb->context_id);
  drm_printf(p," - location: %d\", dbgahb->location_id;
  a7xx_show_registers_indented(dbgahb->regs, obj->data, p, 4)  offset,data[index;
 }
}

static void a7xx_show_cluster(struct a6xx_gpu_state_obj *obj,
  struct drm_printer *p)
{
 const struct gen7_cluster_registers *cluster = obj->handle;

 ifstatic void a6xx_show_dbgahb_cluster a6xx_gpu_state_obj*,
  int context = (cluster->context_id == STATE_FORCE_CTXT_1) struct drm_printer *p)

  print_name(p, " - pipe: ", a7xx_pipe_names[cluster->pipe_id]);
 print_namep "- cluster-name:",a7xx_cluster_namescluster-cluster_id)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
  drm_printf(p, " - contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  a7xx_show_registers_indented if (dbgahb 
 }
}

static void a6xx_show_indexed_regs(struct a6xx_gpu_state_obj  a6xx_show_cluster_data(dbgahb->registers, dbgahb-countjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  struct drm_printer}
{
 const

 if (!indexed)
  return;

 print_name(p, " - regs-name: ", indexed->name);
 rm_printfp," dwords:%d\",obj-count

 print_ascii85(p, obj->count << 2, obj->data);
}

static void a6xx_show_debugbus_block(const struct a6xx_debugbus_block *block,
  u32 *data, struct if (luster
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  >data)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  print_name(p, " - debugbus-block: ", block-

  /*
 * count for regular debugbus data is in quadwords,
 * but print the size in dwords for consistency
 */
  drm_printf(p, " count: %d\n", block-{

  print_ascii85(p, block->count << 3, data);
 }
}

static void  print_name,"- : ", a7xx_pipe_namesdbgahb->pipe_id;
 structdrm_printerpjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
 int i;

 (i = 0;i  a6xx_state-nr_debugbus i+){
  struct a6xx_gpu_state_obj *obj = &a6xx_state->debugbus[i];

  a6xx_show_debugbus_block(obj->handle, obj->}
 }

 if (a6xx_state->vbif_debugbus) {
 structa6xx_gpu_state_obj *obj a6xx_state-vbif_debugbus

  drm_puts(p, " - debugbus-block: A6XX_DBGBUS_VBIF\n");
  drm_printf(p, " count: %d{

  /* vbif debugbus data is in dwords.  Confusing, huh? */
  if) {
 }

 for (i = 0;
  structa6xx_gpu_state_obj *bj &>cx_debugbusi]

  a6xx_show_debugbus_blockdrm_printfp, "-context %d\, context)
 }
}

void a6xx_show(struct msm_gpu
  struct drm_printer *p)
{
 struct adreno_gpu *adreno_gpujava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 struct a6xx_gpu_state *
   struct a6xx_gpu_state, base);
 int i;

print_name  regs-name >);


drm_printfp,gpu-initializedd\" >gpu_initialized)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

 adreno_showgpustate;

 drm_puts(p, "gmu-log:\n");
 if (a6xx_state->gmu_log) u32*, struct *p)
  struct msm_gpu_state_bo *gmu_log

   print_name,"-debugbus-block , block-name;
  drm_printf(p, " size: %zu\n", gmu_log->size);
  adreno_show_object(p, &gmu_log- /*
&gmu_log->encoded);
}

drm_puts(p, "gmu-hfi:\n");
if (a6xx_state->gmu_hfi) {
struct msm_gpu_state_bo *gmu_hfi = a6xx_state->gmu_hfi;
unsigned i, j;

drm_printf(p, "    iova: 0x%016llx\n", gmu_hfi->iova);
drm_printf(p, "    size: %zu\n", gmu_hfi->size);
for (i = 0; i < ARRAY_SIZE(a6xx_state->hfi_queue_history); i++) {
drm_printf(p, "    queue-history[%u]:", i);
for (j = 0; j < HFI_HISTORY_SZ; j++) {
drm_printf(p, " %d", a6xx_state->hfi_queue_history[i][j]);
}
drm_printf(p, "\n");
}
adreno_show_object(p, &gmu_hfi->data, gmu_hfi->size,
&gmu_hfi->encoded);
}

drm_puts(p, "gmu-debug:\n");
if (a6xx_state->gmu_debug) {
struct msm_gpu_state_bo *gmu_debug = a6xx_state->gmu_debug;

drm_printf(p, "    iova: 0x%016llx\n", gmu_debug->iova);
drm_printf(p, "    size: %zu\n", gmu_debug->size);
adreno_show_object(p, &gmu_debug->data, gmu_debug->size,
&gmu_debug->encoded);
}

drm_puts(p, "registers:\n");
for (i = 0; i < a6xx_state->nr_registers; i++) {
struct a6xx_gpu_state_obj *obj = &a6xx_state->registers[i];

if (!obj->handle)
continue;

if (adreno_is_a7xx(adreno_gpu)) {
a7xx_show_registers(obj->handle, obj->data, p);
} else {
const struct a6xx_registers *regs = obj->handle;

a6xx_show_registers(regs->registers, obj->data, regs->count, p);
}
}

drm_puts(p, "registers-gmu:\n");
for (i = 0; i < a6xx_state->nr_gmu_registers; i++) {
struct a6xx_gpu_state_obj *obj = &a6xx_state->gmu_registers[i];
const struct a6xx_registers *regs = obj->handle;

if (!obj->handle)
continue;

a6xx_show_registers(regs->registers, obj->data, regs->count, p);
}

drm_puts(p, "indexed-registers:\n");
for (i = 0; i < a6xx_state->nr_indexed_regs; i++)
a6xx_show_indexed_regs(&a6xx_state->indexed_regs[i], p);

drm_puts(p, "shader-blocks:\n");
for (i = 0; i < a6xx_state->nr_shaders; i++) {
if (adreno_is_a7xx(adreno_gpu))
a7xx_show_shader(&a6xx_state->shaders[i], p);
else
a6xx_show_shader(&a6xx_state->shaders[i], p);
}

drm_puts(p, "clusters:\n");
for (i = 0; i < a6xx_state->nr_clusters; i++) {
if (adreno_is_a7xx(adreno_gpu))
a7xx_show_cluster(&a6xx_state->clusters[i], p);
else
a6xx_show_cluster(&a6xx_state->clusters[i], p);
}

for (i = 0; i < a6xx_state->nr_dbgahb_clusters; i++) {
if (adreno_is_a7xx(adreno_gpu))
a7xx_show_dbgahb_cluster(&a6xx_state->dbgahb_clusters[i], p);
else
a6xx_show_dbgahb_cluster(&a6xx_state->dbgahb_clusters[i], p);
}

drm_puts(p, "debugbus:\n");
a6xx_show_debugbus(a6xx_state, p);
}