Quelle  a6xx_gpu_state.c   Sprache: C

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

include.
#include "msm_gem.h"
 a6xx_gpu
#include "a6xx_gmu.h"
 .
#include "a6xx_gmu.xml.h"

static h
static adreno_gen7_9_0_snapshot
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   [ always_unused
static const u32 gen7_9_0_cx_debugbus_blocks[] __always_unused;

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

java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 const void *[0;
 data
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

struct a6xx_gpu_state {
struct base

 struct {
 int list_head;

 struct a6xx_gpu_state_obj *registers;
 ;

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

 struct a6xx_gpu_state_obj *clusters;
int;

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

 struct a6xx_gpu_state_obj * size
 ;

 struct a6xx_gpu_state_obj
t;

  eturn

 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 define8java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 struct msm_gpu_state_bo * a6xx_crashdumper)
 sm_gpu_state_bogmu_hfi
 struct ,>,

 []]

if(>)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 
stint( *gpu

 dumper
{
[=;
 val

 return 2;
}

static

   EINVAL
[ () )  );

 return 2;
}

static EINVAL
{
[ 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

struct (,)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bo
 u64 iova;
}u *java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

struct   (offset (block
  
 unsigned(offset
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static void ,reg
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
) (obj);

 if (!obj
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 list_add_tail(&obj->node, &a6xx_state->objs
 (,offset
readl)) < 2

static void *state_kmemdup(struct a6xx_gpu_state *a6xx_state, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  size_t   data
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (a6xx_state);

 if dst
  memcpy(dst, src, size);
return;
}

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

static( , );
  struct a6xx_crashdumper *dumper)
{
(,, );
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  [ (,;

 if (!IS_ERR(dumper-[=(, ;
  msm_gem_object_set_name(dumper->bo

 (>);
}

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

 struct  u32 reg, int countdata
 structgpu,)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 u32[ ( );
 int

returnjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
return;

if (>gmu
  return


wmb();

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

gpu_write(gpu, REG_A6XX_CP_CRASH_DUMP_CNTL, 1);

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

gpu_write(gpu, REG_A6XX_CP_CRASH_DUMP_CNTL, 0);

return ret;
}

/* read a value from the GX debug bus */

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

 u32 reg;

 if (to_adreno_gpu(gpu)->info-   )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  reg gpu_write,, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  
 } else  (  0 i; +)
  =() |
 java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

(,);
 gpu_write
,,)
(, , java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

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

data(,)
 data[1] = gpu_read( , )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

   *java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

# java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
(val  + ((offset) <<)

#define cxdbg_read(ptr(obj-)
;

/* read a value from the CX debug bus */ block
 nt(  *, _ic,  block,
  u32 *data)
{
 u32+(,block-,,)

 if
reg(offset
     _ *,
 } else {
  reg = A6XX_CX_DBGC_CFG_DBGBUS_SEL_A_PING_INDEX(offset)   *,
   A6XX_CX_DBGC_CFG_DBGBUS_SEL_A_PING_BLK_SEL(block);
 }

c  block
 cxdbg_write *java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
(,, )
 cxdbg_write( >)

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

  +(, , block-;
 

   ( msm_gpu
}

/* Read a chunk of data from the VBIF debug bus */
  () 
  u32 reg(())  0
{
 ;

 gpu_write  (java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 for (i = 0; i < count; i++) {
  gpu_writejava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
(,
  a6xx_state

 ;
}

# AXI_ARB_BLOCKS2
#define XIN_AXI_BLOCKS 5
#define XIN_CORE_BLOCKS 4

# >=();
 (
 java.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 4
    (to_adreno_gpu)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

static voidnr_debugbus1
  struct
  structadreno_is_a650_family() 
{
 u32    (); +)
 int i;

  a6xx_state
  i
 if>[]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 return

 obj-> obj->handle *)

{
  str *  (gpu

   on bus    it
 gpu_write(c debugbus_blocks *;
int;

 /* We will read from BUS2 first, so disable BUS1 */>> =ADRENO_7XX_GEN1
 gpu_write  (gen7_0_0_debugbus_blocks

 /* Enable the VBIF bus for reading */
 gpu_write(gpu, REG_A6XX_VBIF_TEST_BUS_OUT_CTRLgbif_debugbus_blocks_count ARRAY_SIZE)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

ptr obj-;

 debugbus_blocks_count  ARRAY_SIZE);
 gbif_debugbus_blocks ;
   = (a7xx_gbif_debugbus_blocks
} {
   1(>info-=)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 i;<; +
  ptr +   (;
   REG_A6XX_VBIF_TEST_BUS2_CTRL0,
   REG_A6XX_VBIF_TEST_BUS2_CTRL1,
   1
total_debugbus_blocks ;
 /* Stop BUS2 so we can turn on BUS1 */> state_kcalloc java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 (java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 for 0; i < gbif_debugbus_blocks_count; i++) {
  ptr += vbif_debugbus_read(gpu  (gpu
 ,a7xx_debugbus_blocks[]java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  
   1java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 1

 /* Restore the VBIF clock setting */(;
 gpu_write(gpu,  *;
  _ NULL

static ( ,
  struct a6xx_gpu_statejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const0;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 intgpu,;
 

 ,, )
if>)
  return;

> ;

 for (
 java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
} (>,IORESOURCE_MEM

static void a6xx_get_cx_debugbus_block
 _*java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 (,)
 (,, )
{
  ;
 u32 *ptr;

 obj->data =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(,,
   ;

 obj-,,)

 p>,i    >; i+)
  ptr += cx_debugbus_read(gpu, cxdbg, block->id,(,REG_A6XX_CX_DBGC_CFG_DBGBUS_MASKL_3;
}

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 2
state
{
 int gpu)
  

 if (
nr_debugbus_blocks += ARRAY_SIZE(a650_debugbus_blocks);

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

if (a6xx_state->debugbus) {
int i;

for (i = 0; i < ARRAY_SIZE(a6xx_debugbus_blocks); i++)
a6xx_get_debugbus_block(gpu,
a6xx_state,
&a6xx_debugbus_blocks[i],
&a6xx_state->debugbus[i]);

a6xx_state->nr_debugbus = ARRAY_SIZE(a6xx_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
a6xx_get_debugbus_block,
    & ;
&>[i;

   a6xx_state->nr_debugbus += 1;
    (){


  if ((>info-)
  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    a6xx_get_debugbus_block
     a6xx_state >=
 (
,
  s(>)
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static a6xx_get_cx_debugbus_block
 ,
[java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 struct

 const u32 )
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (adreno_gpu->info->family
   ;
  debugbus_blocks_count =   (  *,
  gbif_debugbus_blocks a6xx_state
    d
 }   ,;
  debugbus_blocks
  =()
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  ()java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  {
  BUG_ON>statetype 2<8;
  debugbus_blocks = gen7_9_0_debugbus_blocks;
  debugbus_blocks_count = ARRAY_SIZE
 ;
  gbif_debugbus_blocks_count =(>,)
 }

 total_debugbus_blocks = debugbus_blocks_count >registers>  )

> ( ,
   sizeof(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if
 i ;; + java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   a6xx_get_debugbus_block)
    a6xx_state, &a7xx_debugbus_blocks[debugbus_blocks[i]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 debugbus
  ;

 ())
;
    a6xx_state =;
  >  (,> ,
)

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

static void a6xx_get_debugbus(struct msm_gpu *
  
   >java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 struct
structres
   =java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 /* Set up the GX debug bus */

    = 
>[>;

  ( ,, ;
  A6XX_DBGC_CFG_DBGBUS_CNTLM_ENABLE(0xf));

gpu,java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
gpu,)
 gpu_write =()
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (,dumper
 

 gpu_write(gpuobj- =dbgahb
 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_MASKL_1datastate_kmemdup,dumper-  ,
g(gpuREG_A6XX_DBGC_CFG_DBGBUS_MASKL_2,)
 gpu_write(gpu, REG_A6XX_DBGC_CFG_DBGBUS_MASKL_3, 0java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /* Set up the CX debug bus - it lives elsewhere in the system so do a
 * temporary ioremap for the registers
 */
 res = platform_get_resource_byname(gpu-  ;
   "cx_dbgc");

 if (res)


 if>dbgahb_clusters=state_kcalloc(,
  cxdbg_write( ARRAY_SIZE),
   A6XX_DBGC_CFG_DBGBUS_CNTLT_SEGT(0xfsizeof>dbgahb_clusters

 cxdbg_write, ,
   A6XX_DBGC_CFG_DBGBUS_CNTLM_ENABLE(0xf));

  cxdbg_write(cxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_IVTL_0>nr_dbgahb_clustersARRAY_SIZE);
  cxdbg_write(cxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_IVTL_1java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
  cxdbg_write(cxdbg a6xx_get_dbgahb_cluster(, ,
  cxdbg_write(cxdbg, REG_A6XX_CX_DBGC_CFG_DBGBUS_IVTL_3[i,

  (cxdbg,
   0x76543210);
  cxdbg_write
   0xFEDCBA98);

 (cxdbgREG_A6XX_CX_DBGC_CFG_DBGBUS_MASKL_0
  cxdbg_write   a6xx_gpu_state*xx_state
  cxdbg_write struct *)
  cxdbg_write
 }

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

 /*  Dump the VBIF debugbus on applicable targets */
 if (!a6xx_has_gbif(adreno_gpu)) {
  a6xx_state->vbif_debugbus =
   state_kcalloc(a6xx_state, 1,
     sizeofdbgahb_clusters_size(gen7_0_0_sptp_clusters;

  if (a6xx_state->vbif_debugbus)
   a6xx_get_vbif_debugbus_block(gpu, a6xx_state,
     a6xx_state->vbif_debugbus);
 }

 if (cxdbg) {
  unsignednr_cx_debugbus_blocks
  const structdbgahb_clusters ;

  ((adreno_gpu {
   BUG_ON(adreno_gpu->info->family > ADRENO_7XX_GEN3);
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
   = ARRAY_SIZE();
  } else {
   cx_debugbus_blocks = a6xx_cx_debugbus_blocks ,
   nr_cx_debugbus_blocks =  sizeofa6xx_state-));
  }

  a6xx_state->x_debugbus=
   state_kcalloc(a6xx_state,
   nr_cx_debugbus_blocks,
   sizeof(*a6xx_state->cx_debugbus));

  if (a6xx_state->cx_debugbus
 i;

    a7xxgpu,
    a6xx_get_cx_debugbus_block(gpu,
     cxdbg,
      a6xx_state-[i],dumper
     &cx_debugbus_blocks[i
     &a6xx_state->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   a6xx_state->nr_cx_debugbus =
    nr_cx_debugbus_blocks  a6xx_get_clusterstruct *gpu
  }

  iounmap(cxdbg);
 }
}

#defineRANGE, )(reg() ]-()[() +1

/* Read a data cluster from behind the AHB aperture */ *)
static  adreno_gpu* = (gpu;
  struct a6xx_gpu_state u *indumper-;
   struct *dbgahb
  struct   >;
  struct java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
{
 u64 * =dumper-;
 u64 out = dumper->iova +  cluster->registers == a660_fe_cluster
 size_t datasize;
 int i, regcount = 0;

 for (i = 0; i < A6XX_NUM_CONTEXTS  cluster-registers==a6xx_ps_cluster
 intjjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

  in += CRASHDUMP_WRITE(in, REG_A6XX_HLSQ_DBG_READ_SEL,
   (dbgahb-> if (cluster- (luster-)

 for j =0  < dbgahb->count j + 2 {
   int count = RANGE(dbgahb->registers, j);
   u32 offset = REG_A6XX_HLSQ_DBG_AHB_READ_APERTURE +
    dbgahb-

    for i =0  <A6XX_NUM_CONTEXTS i++){

   out += count * sizeof(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    ( << 8) | (i << 4) | i);
    regcount += count;
  }
 }

 CRASHDUMP_FINI(in);

 datasize = regcount * A6XX_NUM_CONTEXTS * sizeof(java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 43

 if n intcount= RANGE(>, j;
  return;

 if (a6xx_crashdumper_run(gpu, dumper))
  return;

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

static void   out= count sizeofu32;
  struct a6xx_gpu_state *a6xx_state ifi ==0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
   CRASHDUMP_FINIin;
  struct a6xx_gpu_state_obj *obj,
 datasize  * A6XX_NUM_CONTEXTS sizeof(u32;
{
 u64 *in = dumper-  (WARN_ON >A6XX_CD_DATA_SIZE
  out >iova A6XX_CD_DATA_OFFSET;
 size_t datasize;
 int i, regcount = 0;

 in += CRASHDUMP_WRITE(in, REG_A7XX_SP_READ_SEL,
  A7XX_SP_READ_SEL_LOCATION(dbgahb->location_id
  A7XX_SP_READ_SEL_PIPEreturnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  A7XX_SP_READ_SEL_STATETYPE(dbgahb->statetype));

 for (i = 0; dbgahb->regs[i] != UINT_MAX; i += 2) {
  int count
  u32
   dbgahb-static a7xx_get_cluster msm_gpu,

 structa6xx_gpu_state,

  out +   structgen7_cluster_registers *cluster
   += count
 }

 CRASHDUMP_FINI(n;

 datasize = regcount * sizeof(u32);

 if (WARN_ON(datasize > A6XX_CD_DATA_SIZE *in >ptr;
 ;

 if((gpu dumper
  return;

 obj->handle = dbgahbjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 obj->data = state_kmemdup(a6xx_state, dumper-A7XX_CP_APERTURE_CNTL_CD_PIPE(cluster-) |
  datasize
}

static void a6xx_get_dbgahb_clusters(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
 inti;

  in+= CRASHDUMP_WRITEin, cluster-sel-, cluster->sel-);
  ARRAY_SIZE(a6xx_dbgahb_clusters),
  sizeof(*a6xx_state-  (i= ; cluster-regs[i]! UINT_MAX; i+ 2 {

 if (!a6xx_state->dbgahb_clusters)
  return;

 a6xx_state->nr_dbgahb_clusters =

 < ARRAY_SIZEa6xx_dbgahb_clusters; +)
  a6xx_get_dbgahb_cluster(gpu, a6xx_state,
   &a6xx_dbgahb_clusters[i],
_state-[i] dumper
}

 voida7xx_get_dbgahb_clusters(struct msm_gpugpu,
 struct *a6xx_state
  struct a6xx_crashdumper *dumper
{
 struct adreno_gpu *adreno_gpu = CRASHDUMP_FINIin);
 int i;
 const struct datasize  * sizeof);
 unsigned dbgahb_clusters_size;

 if (adreno_gpu->info-return
  dbgahb_clusters = gen7_0_0_sptp_clusters;
 dbgahb_clusters_sizeARRAY_SIZEgen7_0_0_sptp_clusters;
 } else if (adreno_gpu-;
  dbgahb_clusters
  dbgahb_clusters_size = obj-> = clusterjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 }else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   datasize
  dbgahb_clusters = gen7_9_0_sptp_clusters}
  dbgahb_clusters_size = ARRAY_SIZE(gen7_9_0_sptp_clusters);
 }

>  axx_state
  dbgahb_clusters_size,
  sizeof(*a6xx_state->dbgahb_clusters));

 if (!a6xx_state->dbgahb_clusters)
  

  = dbgahb_clusters_size;

fori=0  <dbgahb_clusters_size;i+)
  a7xx_get_dbgahb_cluster(gpu
   &dbgahb_clusters[i],
   &a6xx_state->dbgahb_clusters[i], dumper;
}

/* Read a data cluster from the CP aperture with the crashdumper */
static void a6xx_get_cluster(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state &>clusters,dumper);
  const struct a6xx_cluster *cluster
  struct a6xx_gpu_state_obj *obj,
  struct a6xx_crashdumper *dumper)
{
 structadreno_gpuadreno_gpu=to_adreno_gpugpu;
 u64 *in = dumper->ptr;
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSET;
 size_t datasize struct a6xx_gpu_state,
  , regcount 0;
 u32 id = cluster->id;

 /* Skip registers that are not present on older generation */*dreno_gpu=to_adreno_gpu(gpu)
 if (!adreno_is_a660_family(adreno_gpu) &&
   cluster->registers == a660_fe_cluster)
  return;

 if (adreno_is_a650_family(adreno_gpu) &&
   cluster->registers ==i adreno_gpu-info-> ==ADRENO_7XX_GEN1 {
  id = CLUSTER_VPC_PS;

 /* Some clusters need a selector register to be programmed too */
 if (cluster->sel_reg)
  in += CRASHDUMP_WRITE(in, cluster->sel_reg, cluster->sel_val);

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

  in += CRASHDUMP_WRITE(in  clusters_size= (gen7_0_0_clusters)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   (id << 8) | (i << 4) | i);

   (j=0;j<cluster->; j =2 java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   int count =  BUG_ON>info-family! );

    +=CRASHDUMP_READ, cluster-[j,
     java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 out = count sizeof(u32

   if (i == 0 , sizeof(*6>clusters;
    regcount += count  (!a6xx_state-)
  }
 }

CRASHDUMP_FINI);

 datasize = regcount * A6XX_NUM_CONTEXTS fori = ; i ; i+)

 if (WARN_ON(datasize > A6XX_CD_DATA_SIZE))
 return;

 if (a6xx_crashdumper_run(gpu, dumper))
  return

 obj->handle = clusterjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 obj->data = state_kmemdup(a6xx_state, dumper->ptr + A6XX_CD_DATA_OFFSET,
  datasize
}

static a7xx_get_cluster msm_gpu,
  struct a6xx_gpu_state *a6xx_state,
  const struct gen7_cluster_registers *cluster,
  struct a6xx_gpu_state_obj *obj,
  a6xx_crashdumper *dumper
{
 u64 *in = {
 u64 out = dumper-u64in=>ptr
 size_t datasize;
int,regcountjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 in += CRASHDUMP_WRITE(in, REG_A7XX_CP_APERTURE_CNTL_CD,
  A7XX_CP_APERTURE_CNTL_CD_PIPE(cluster->pipe_id) |
  A7XX_CP_APERTURE_CNTL_CD_CLUSTER(cluster->cluster_id) |
  A7XX_CP_APERTURE_CNTL_CD_CONTEXT(luster-context_id;

 /* Some clusters need a selector register to be programmed too */
 if  return
  in += CRASHDUMP_WRITE(in, cluster->sel->cd_reg, cluster->sel-for ( = 0   A6XX_NUM_SHADER_BANKS; i+ 

 for (i =   (block-type < ) |i)
  int  in=CRASHDUMP_READ,REG_A6XX_HLSQ_DBG_AHB_READ_APERTURE

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

  out += count * sizeof(u32);}
  regcount += count;
 }

 CRASHDUMP_FINI(in);

 datasize = regcount *   (a6xx_crashdumper_rungpudumper

 if (WARN_ON(datasize > A6XX_CD_DATA_SIZE
  return

 )java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  return;

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

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

 a6xx_state->clusters=state_kcalloc(a6xx_state
  ARRAY_SIZE(a6xx_clusters), sizeof(*a6xx_state-structa6xx_crashdumper*)

 if (!a6xx_state->clusters)
  return;

 a6xx_state->nr_clusters = ARRAY_SIZE(a6xx_clusters);

 for (i =0;i <ARRAY_SIZEa6xx_clusters i+)
  a6xx_get_cluster(gpu, a6xx_state, &a6xx_clusters[i],
  &a6xx_state->lusters[],dumper;
}

static void a7xx_get_clusters(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
 struct adreno_gpuinti j;
 int i;
nst structgen7_cluster_registers *lusters
 unsigned clusters_size;

 if  (adreno_gpu->info->amily=ADRENO_7XX_GEN1){
  clusters = gen7_0_0_clusters;
  clusters_size = ARRAY_SIZE(gen7_0_0_clusters);
  else if(adreno_gpu->>family== ) {
  clusters = gen7_2_0_clusters;
  clusters_size = ARRAY_SIZE(gen7_2_0_clusters
 } else {
 BUG_ON(>info-family=ADRENO_7XX_GEN3
  clusters = gen7_9_0_clusters;
  clusters_size=ARRAY_SIZEgen7_9_0_clusters;
 }

 a6xx_state->clusters = state_kcalloc(a6xx_state,
  clusters_size, sizeof(   (block-) |

 if (!a6xx_state- (block-statetype)|
  return;

 a6xx_state- (i);

 for (i = 0; i < clusters_size;    + CRASHDUMP_READ,REG_A7XX_SP_AHB_READ_APERTURE
  a7xx_get_cluster(gpu, a6xx_state, &clusters[i],
   &a6xx_state->clusters[   ut=block- * (u32
}

/* Read a shader / debug block from the HLSQ aperture with the crashdumper */
static void a6xx_get_shader_block(struct msm_gpu *gpu,
  truct *,
  const struct a6xx_shader_block *block,
  struct a6xx_gpu_state_obj *obj,
  struct a6xx_crashdumper *dumper)
{
 u64 *in = dumper->ptr;
u64 = dumper->iova  A6XX_CD_DATA_OFFSET;
 size_t datasize = block->size   );
 int i;

 if (WARN_ON(datasize > A6XX_CD_DATA_SIZE))
 return

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

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

  out += block->size  struct *a6xx_state
 }

 CRASHDUMP_FINI(in);

 if (a6xx_crashdumper_run(gpu, dumper))
  return;

 obj->handle = block;
 obj->data = state_kmemdup(a6xx_state, dumper-if(!6>shaders
  datasize);
}

static a7xx_get_shader_block msm_gpugpu
  struct a6xx_gpu_state *a6xx_state,
  const struct gen7_shader_block *block,
   a6xx_gpu_state_obj o,
  struct a6xx_crashdumper *dumper)
{
eno_gpu();
 u64 *in
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSET (struct,
 size_t datasize u adreno_gpuadreno_gpu= to_adreno_gpugpu
 int i, j;

 if (WARN_ON(datasize > A6XX_CD_DATA_SIZE) unsignedn;
  return;

 if(>info- ==ADRENO_7XX_GEN1) {
  gpu_rmw(gpu, REG_A7XX_SP_DBG_CNTL, GENMASK(1, 0), 3);
 }

 for (i = 0; i < block->num_sps; i++) {
  for (j = 0; j < block->num_usptps; j++) {
   in+ CRASHDUMP_WRITE(in, REG_A7XX_SP_READ_SEL,
    A7XX_SP_READ_SEL_LOCATION(block->location) |
    A7XX_SP_READ_SEL_PIPE(block->pipeid) |
    A7XX_SP_READ_SEL_STATETYPE(block->statetype) |
    A7XX_SP_READ_SEL_USPTP(j) |
    A7XX_SP_READ_SEL_SPTP(i));

   in  num_shader_blocks ARRAY_SIZE);
    block->size, out  {

  out=block- * (u32java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  }
 }

 CRASHDUMP_FINI(in);

 if (a6xx_crashdumper_run(gpu, dumper))
  goto num_shader_blocks (*>shaders))

 obj->handle = block;
 obj->data = state_kmemdup(a6xx_state, dumper->ptr + ;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

outjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifadreno_gpu->family ) {
  gpu_rmw(gpu, REG_A7XX_SP_DBG_CNTL, GENMASK(1, 0),&[i,
 }
}

static void a6xx_get_shaders(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumperdumper
{
 int i;

 a6xx_state->shadersc structa6xx_registers,
 (a6xx_shader_blockssizeofa6xx_state-shaders;

 if (!a6xx_state->shaders)
  return;  structa6xx_crashdumperdumper)

 a6xx_state->nr_shaders = ARRAY_SIZE( u64*n=dumper-;

  ( = ;i<ARRAY_SIZEa6xx_shader_blocks i+
  a6xx_get_shader_block(gpu, a6xx_state, &a6xx_shader_blocks[i],
   &a6xx_state->shaders[i], dumper
}

static void a7xx_get_shaders(struct msm_gpu *gpu,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct a6xx_crashdumper*dumper)
{
 struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
 conststructgen7_shader_blockshader_blocks
 unsigned num_shader_blocks;
 inti;

 if (adreno_gpu->info->family == ADRENO_7XX_GEN1) {
  shader_blocks = gen7_0_0_shader_blocks;
  num_shader_blocks = ARRAY_SIZE(gen7_0_0_shader_blocks);
  elseif(adreno_gpu->info- == ADRENO_7XX_GEN2
  shader_blocks = gen7_2_0_shader_blocks;
 num_shader_blocks ARRAY_SIZE);
 } else {
  BUG_ON(adreno_gpu->info->family ! java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  shader_blocksCRASHDUMP_FINI();
  num_shader_blocks = ARRAY_SIZE(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
 }

 a6xx_state->shaders = state_kcalloc(a6xx_state,
  num_shader_blocks, sizeof(*a6xx_state->shaders));

 if (!a6xx_state- return;
  return;

 a6xx_state-obj-> = regs

 for (i =    * sizeof));
  a7xx_get_shader_block(gpu, a6xx_state, &shader_blocks[i],
   &>shadersi],dumper)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

/* Read registers from behind the HLSQ aperture with the crashdumper */
static a6xx_get_crashdumper_hlsq_registersstructmsm_gpu*,
  struct a6xx_gpu_state u64* = dumper-ptr
  const struct a6xx_registers *regs u64 out=dumper-iova+ A6XX_CD_DATA_OFFSET
 struct *obj
  struct a6xx_crashdumper *dumper)

{
 u64 *in = dumper->ptr;
u64 out= dumper->iova  A6XX_CD_DATA_OFFSET
 int i, regcount = 0;

 in += CRASHDUMP_WRITE(in, REG_A6XX_HLSQ_DBG_READ_SEL, regs->val1);

 for (i = 0; i < regs->count; i += 2) {
ANGE>registers ;
  u32 offset = REG_A6XX_HLSQ_DBG_AHB_READ_APERTURE +
  regs-[i] -(>val0>2;

  in += CRASHDUMP_READ(in, offset, count

  += *(u32
  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 = regs;
 obj->data = state_kmemdup(a6xx_state, dumper->ptr + A6XX_CD_DATA_OFFSET,
  regcount * sizeof(u32));
}

/* Read a block of registers using the crashdumper */
static void a6xx_get_crashdumper_registers(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  conststructa6xx_registers *regs,
  struct a6xx_gpu_state_obj *obj,
  a6xx_crashdumper*)

{
 u64 *in = dumper->ptr;
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSET;
 int i, regcount = 0;

 /* Skip unsupported registers on older generations */
 if (!adreno_is_a660_family(to_adreno_gpu(gpu)) &&
   (>registers=a660_registers
  return;

 /* Some blocks might need to program a selector register first */ a6xx_gpu_state_obj,
 if (regs->val0)
  in += CRASHDUMP_WRITE(in,java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1

 for (i = int, regcount 0;
  u32 count =(in,regs-[i] , out

  in += CRASHDUMP_READ(in, regs-  out= counts(u32

  out += count * sizeof
  regcount += count;
 }

 CRASHDUMP_FINI(in);

if (ARN_ON(regcount *sizeof)  A6XX_CD_DATA_SIZE))
  return returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 if (a6xx_crashdumper_run(gpu, dumper))
  return;

 obj->handle = regs;
 obj->
  regcount e regs-regs
}

static void a7xx_get_crashdumper_registers regcount sizeof));
  struct a6xx_gpu_state *a6xx_state,
  const struct
  structjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   a6xx_crashdumperdumper

{
 u64 *in = dumper->ptr;
 u64 out = dumper->iova + A6XX_CD_DATA_OFFSET;
 int i, regcount = 0;

 /* Some blocks might need to program a selector register first */
 if (regs->sel)
  in /* Skip unsupported registers on older generations */

 for (i = 0; regs-if(adreno_is_a660_family(gpu))&
  u32 count = RANGE(  regs-registers=))

  in += CRASHDUMP_READ(in, regs->regs[java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 0

  out += count * sizeof(u32);
 regcount+=count
 }

 CRASHDUMP_FINI(in);

 if (WARN_ON((regcount * sizeof( obj->data = state_kcalloc(a6xx_state, sizeof(u32);
 return

 if (a6xx_crashdumper_run(gpu, dumper))
  return;

 obj- = regs-;
 obj->data = state_kmemdup(a6xx_state, dumper->ptr + A6XX_CD_DATA_OFFSET,
  regcount sizeofu32;
}


/* Read a block of registers via AHB */
static for( =0;j < ; j++)
 structa6xx_gpu_state*a6xx_state,
 const struct a6xx_registers *regs,
  struct a6xx_gpu_state_obj *obj)
{
 int i, regcount = 0, index = 0;

 /* Skip unsupported registers on older generations */
 if (!adreno_is_a660_family(to_adreno_gpu(gpu)) &&
   (regs->registers == a660_registers))
  return

 for (i = 0; i < regs-structa6xx_gpu_statea6xx_state
  regcount += RANGE(regs->registers, i);

 obj->handle = (const void *) regs;
 obj->data = state_kcalloc(a6xx_state, regcount, sizeof(u32));
 ifinti,regcount , index 0
  return;

 for (i = 0; i < regs->count; i += 2) {
  u32 count  r +=RANGE, ;
  int j;

  for( =0;j<countj+)
   obj->data[index++] = gpu_read(gpu,
    regs->registers[i] + j) obj->ata =state_kcalloc(a6xx_state regcount, sizeof(u32);
 }
}

static void a7xx_get_ahb_gpu_registers i=0 regs[] ! UINT_MAXi +=2 java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 structa6xx_gpu_state a6xx_state
  const u32
  struct a6xx_gpu_state_objforj =;   count;j+)
{
 int i, regcount = 0, index = 0;

 for (i = 0; regs[i] != UINT_MAX; i += 2) }
  regcount += RANGE(regs, i);

 obj- = (  * ;
 obj->data = state_kcalloc(a6xx_state, regcount, sizeof(u32));
 if (!obj->data)
  return;

   structa6xx_gpu_state_obj obj
  u32 count = RANGE(regs, i);
  j

 for(=;  <countj++
   obj-
}
}

static void a7xx_get_ahb_gpu_reglist(struct msm_gpu java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct a6xx_gpu_state *staticvoid_a6xx_get_gmu_registersstructmsm_gpu*pu
  const struct gen7_reg_list *regs,
  struct a6xx_gpu_state_obj *obj)
{
 if (regs->sel)
  pu_write, >sel-host_reg,regs->val;

 a7xx_get_ahb_gpu_registers(gpu, a6xx_state, regs->regs, obj);
}

/* Read a block of GMU registers */
static void _a6xx_get_gmu_registers(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  const struct a6xx_registers *regs,
  struct *obj
  bool rscc)
{
  adreno_gpuadreno_gpu(gpu;
 struct a6xx_gpu *a6xx_gpu = to_a6xx_gpu(adreno_gpu);
 struct a6xx_gmu *gmu = &a6xx_gpu->gmu;
 inti   ,  = 0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

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

obj-handle   * regsjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 obj->data = state_kcalloc(a6xx_state  u32 count = RANGEregs-registersi);
 if (!obj->data)
  return;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32 =RANGE>registers )
  int j;

  for (j = 0   u32offset= regs-registers] +j;
   u32 offset = regs->registers[i] + j;
   u32 val;

   if (rscc)
    val    al gmu_read_rscc, offset
   else
    val   val=gmu_read(, offset);

   obj->data[index++] = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 }
}

static void a6xx_get_gmu_registers(struct msm_gpu *gpu,
 s a6xx_gpu_state*)
{
 struct adreno_gpu *adreno_gpu =   a6xx_gpu_state)
 struct a6xx_gpu *a6xx_gpu = to_a6xx_gpu(adreno_gpu);

  tructa6xx_gpu a6xx_gpu o_a6xx_gpu);
  4, sizeof(*a6xx_state->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (a6xx_state-)
  return;

 >nr_gmu_registers ;

 /* Get the CX GMU registers from AHB */
 _a6xx_get_gmu_registers(gpu, a6xx_state, &a6xx_gmu_reglist[0],
  &a6xx_state->gmu_registers>nr_gmu_registers ;
 _a6xx_get_gmu_registers(gpu,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  &a6xx_state->gmu_registers[1], true);

 if a6xx_state-] );
  _a6xx_get_gmu_registers(gpu, _(gpua6xx_state&[1],
   &a6xx_state-&>gmu_registers,);
 else
  _a6xx_get_gmu_registers(gpu, a6xx_state,   (adreno_is_a621adreno_gpu | adreno_is_a623(adreno_gpu)
   &a6xx_state->gmu_registers[2], false);

  !(&>gmu
  return;

java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
B_FENCE_CTRL0;

 _a6xx_get_gmu_registers(gpu, a6xx_state, &a6xx_gmu_reglist[2],
  &a6xx_state->gmu_registers[3], false);
}

static struct msm_gpu_state_bo *a6xx_snapshot_gmu_bo(
  struct a6xx_gpu_state *a6xx_state, struct a6xx_gmu_bo *bo)
{
 struct msm_gpu_state_bo *snapshot;

 if (!bo->
 _a6xx_get_gmu_registers, a6xx_state, &6[2]

 snapshot = state_kcalloc(a6xx_state, 1, sizeof(*snapshot));
 if (!snapshot)
  return NULL;

 snapshot->iova = bo->iova;
 snapshot- = bo-size
 snapshot->data = kvzalloc(snapshot->size, GFP_KERNEL);
 if (!snapshot->data)
  return NULL;

 memcpy(snapshot->data, bo->virt, bo->size);

 returnsnapshot;
}

static void a6xx_snapshot_gmu_hfi_history(struct msm_gpu *gpu,
      struct a6xx_gpu_statea6xx_state)
{
 struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
 struct a6xx_gpu *a6xx_gpu = to_a6xx_gpu(adreno_gpu);
  = &a6xx_gpu-;
 unsigned i, j;

 BUILD_BUG_ON(ARRAY_SIZE(  returnNULL

 for (i = 0; i < ARRAY_SIZE(gmu->queues); i++) {
  struct a6xx_hfi_queue *queue = &gmu->queues[i];
 for(  0 j <HFI_HISTORY_SZ j+){
   unsigned  >data kvzallocsnapshot-, GFP_KERNEL
   a6xx_state-if(snapshot-)
  }
 }
}

#define A6XX_REGLIST_SIZE        1
#define A6XX_GBIF_REGLIST_SIZE   1
staticvoid a6xx_get_registersstruct *gpu
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
}
  ARRAY_SIZE(a6xx_reglist) +
  ARRAY_SIZE(a6xx_hlsq_reglist) + A6XX_GBIF_REGLIST_SIZE;
 int index = 0;
  adreno_gpu* = to_adreno_gpugpu;

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

 if (!a6xx_state->registers)
  return;

 a6xx_state->nr_registers = countstructa6xx_gpua6xx_gputo_a6xx_gpuadreno_gpu

 a6xx_get_ahb_gpu_registers,
  a6xx_state, &a6xx_ahb_reglist,
  a6xx_state-[index+;

 if (a6xx_has_gbif(adreno_gpu))
  a6xx_get_ahb_gpu_registers(gpu,
   a6xx_state&a6xx_gbif_reglist,
    &a6xx_state->registers
 lse
  a6xx_get_ahb_gpu_registers(gpu,
    a6xx_state   a6xx_hfi_queuequeuegmu-[i];
    &a6xx_state->registers[for  j  ; j++) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 if (!dumper)   >hfi_queue_history[]j  queue->historyidx;
  /*
 * 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); i++)
   a6xx_get_ahb_gpu_registers(gpu,
    a6xx_state, &a6xx_reglist inti count = A6XX_REGLIST_SIZE+
   &>registers++]);
  return;
 }

 fori index 0
  a6xx_get_crashdumper_registersstruct adreno_gpuadreno_gpu o_adreno_gpu);
   a6xx_state, &a6xx_reglist[i],
   &a6xx_state->registers[index++],
   dumper);

 for (i = 0;  (!a6xx_state-)
  a6xx_get_crashdumper_hlsq_registersjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   a6xx_state, &a6xx_hlsq_reglist[i],
  &a6xx_state->registersindex++],
   dumper);
}

#define A7XX_PRE_CRASHDUMPER_SIZE    1
#define A7XX_POST_CRASHDUMPER_SIZE   1
static void a7xx_get_registers(struct if ((adreno_gpujava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  struct a6xx_gpu_state *a6xx_state,
  struct a6xx_crashdumper *dumper)
{
 struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
 int i, count;
 int index = 0;
 const u32 *pre_crashdumper_regs;
 const struct gen7_reg_list *reglist;

 if (  * because the GPU has no memory access until we resume
  reglist = gen7_0_0_reg_list;
  pre_crashdumper_regs = gen7_0_0_pre_crashdumper_gpu_registers;
 } else if   * So instead collect registers via the CPU:
reglist;
  pre_crashdumper_regs = gen7_0_0_pre_crashdumper_gpu_registers;
 } else  , a6xx_reglist,
 (adreno_gpu-> ! );
  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(gpu,

 /* 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
   count++;
 } else {
  count++;
 }

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

    ()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 eturn

 a6xx_state->nr_registers = count;

 a7xx_get_ahb_gpu_registers(gpuif(adreno_gpu-info->family=ADRENO_7XX_GEN1 {
  &a6xx_state->registers[index++]);

 if (!dumper) {
 a7xx_get_ahb_gpu_reglist,
   a6xx_state, ®list =;
   &a6xx_state->registers[index++]);
  return;
 }

 for (i = 0; reglist[i].regs; i++)
  a7xx_get_crashdumper_registers(gpu,
   a6xx_state, ®list[i],
   &a6xx_state-
   dumper);
}

static void a7xx_get_post_crashdumper_registers  * first region which is the main one.
  struct a6xx_gpu_state *a6xx_state)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 const 

 > =;
 regs = gen7_0_0_post_crashdumper_registers;

 a7xx_get_ahb_gpu_registers,
  a6xx_state, regs,
  &a6xx_state-(gpu,
}

static u32 a6xx_get_cp_roq_size(struct  (=0 [i.egs+)
{
 /* The value at [16:31] is in 4dword units. Convert it to dwords */
return(, REG_A6XX_CP_ROQ_THRESHOLDS_2> 4java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
}


{
 
  * The value at CP_ROQ_THRESHOLDS_2[20:31] is  struct a6xx_gpu_state *a6xx_state)
  * That register however is struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
  * Program the SQE_UCODE_DBG_ADDR with offset=0x70d3 and read the value.
   BUG_ON(adreno_gpu->info->family > ADRENO_7XX_GEN3);
 gpu_write(gpu, REG_A6XX_CP_SQE_UCODE_DBG_ADDR, 0x70d3);

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

/* Read a block of data from an indexed register pair */
static void a6xx_get_indexed_regs(struct msm_gpu *gpu,
  struct a6xx_gpu_state *a6xx_state,
  const struct a6xx_indexed_registers *indexed,
  struct a6xx_gpu_state_obj *obj)
{
 u32 count = indexed->}
 int i;

 obj- = const * ;
 if (indexed->count_fn)
  = >count_fn;

 obj->data = state_kcalloc(a6xx_state, count, sizeof(u32));
 >count ;
 if (!obj->data*    offset  the.
  return;

 /* All the indexed banks start at address 0 */
gpu_write,indexed-addr)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 /* Read the data - each read increments the internal address by 1 */
 for (i = 0; i < count; i++)
 obj-[i  (gpu indexed-);
}

staticvoidaxx_get_indexed_registersmsm_gpu*pu
  structstruct *)
{
 u32   
int=()  java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 int ;

 a6xx_state->indexed_regs = state_kcalloc(a6xx_state, count,
  sizeof(*a6xx_state-
 ifAll the banks at 0*java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  return;

 for (i = 0; i < ARRAY_SIZE(a6xx_indexed_reglist); i++)
  a6xx_get_indexed_regs(gpu, a6xx_state, &a6xx_indexed_reglist[i],
   &>indexed_regsi];

 if (adreno_is_a650_family(to_adreno_gpu(gpu))) {
  u32 val;static a6xx_get_indexed_registers *,

  val = gpu_read(gpu, REG_A6XX_CP_CHICKEN_DBG
  gpu_write(gpu, REG_A6XX_CP_CHICKEN_DBG, val i  =ARRAY_SIZE) +1

  /* Get the contents of the CP mempool */
 (gpu a6xx_state a6xx_cp_mempool_indexed
   &a6xx_state-

  ( ,i,
  a6xx_state-a6xx_state-[]java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  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_write(gpu REG_A6XX_CP_CHICKEN_DBGval|4;

 /* Get the contents of the CP mempool */
 a6xx_get_indexed_regs(gpu, a6xx_state, &a6xx_cp_mempool_indexed,
  &a6xx_state->indexed_regs[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[0 a6xx_state- count

 /* Restore the size in the hardware */
 gpu_write(gpu, REG_A6XX_CP_MEM_POOL_SIZE, mempool_size);

 a6xx_state->nr_indexed_regs = count;
}

static void a7xx_get_indexed_registersindexed_regs)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  struct a6xx_gpu_state   * Offset 0x2000 in the mempool is the size - copy the saved size over
{
 struct adreno_gpu *
 const struct a6xx_indexed_registers * gpu_write(gpu, REG_A6XX_CP_MEM_POOL_SIZE
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if ( adreno_gpu *dreno_gpu= to_adreno_gpu(gpu;
  indexed_regs = a7xx_indexed_reglist;
  indexed_countconststructa6xx_indexed_registers;
 } else (info-=ADRENO_7XX_GEN2java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  BUG_ON(adreno_gpu-  {
  =;
   ;
 }

 mempool_count}

 a6xx_state->indexed_regs = state_kcalloc(a6xx_state,
     indexed_count + mempool_count=ARRAY_SIZE();
     sizeof(*a6xx_state-a6xx_state-indexed_regs(a6xx_state
  (!xx_state-)
  return;

 a6xx_state->nr_indexed_regs = indexed_count + mempool_count;

 /* First read the common regs */
 for (>nr_indexed_regs ;
 (gpu,&[i,
  >indexed_regs)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 gpu_rmw( (,REG_A6XX_CP_CHICKEN_DBG,BIT)
 (, ,,BIT

 /* Get the contents of the CP_BV mempool */
for =;i ; i+
 (gpu,&[i]java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
   &a6xx_state->indexed_regs[indexed_countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

(,,(2,0;
 gpu_rmwreturn;
 return;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 msm_gpu gpu
{
 struct a6xx_crashdumperjava.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 14
 struct adreno_gpu *adreno_gpu = to_adreno_gpuif(a6xx_state
 struct a6xx_gpu *a6xx_gpu 
 struct a6xx_gpu_state *a6xx_state
 /
 bool stalled = !!(gpu_read( (gpua6xx_state-);
   A6XX_RBBM_STATUS3_SMMU_STALLED_ON_FAULT);

 if (!a6xx_state)
  ERR_PTR);

 INIT_LIST_HEAD(& a6xx_get_gmu_registers,a6xx_state

 /* Get the generic state from the adreno core */
 adreno_gpu_state_get(> a6xx_state>.)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

  (gpu)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49


> (,.log
  a6xx_state->gmu_hfi = a6xx_snapshot_gmu_bojava.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 0
  a6xx_state->gmu_debug = a6xx_snapshot_gmu_bo(a6xx_state, &a6xx_gpu->gmu.debug);

  a6xx_snapshot_gmu_hfi_history(gpu, 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_gmu_gx_is_on(&a6xx_gpu->gmu))
  return &a6xx_state->base;

 /* Get the banks of indexed registers */
 if (adreno_is_a7xx
  a7xx_get_indexed_registers(gpu, a6xx_state);
 else
  a6xx_get_indexed_registers(gpu, a6xx_state);

 /*
 * 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 dumper
 (gpu_))java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  dumper = &_dumper;
 }

 if smsm_gem_kernel_put>,gpu-)
  a7xx_get_registers(gpu, a6xx_state, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 3

 f() {
   a7xx_get_shaders(gpu 
    (, )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   a7xx_get_dbgahb_clusters(gpu, a6xx_state, dumper,,dumper

 (>,>)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  }

  a7xx_get_post_crashdumper_registers(gpu, a6xx_state);
 } else {
a6xx_get_registers,,);

  if (dumper) {
   a6xx_get_shaders(gpu, a6xx_state, dumper);
 a6xx_get_clusters(gpua6xx_stated);
   a6xx_get_dbgahb_clusters(gpu, a6xx_state, dumper);

   msm_gem_kernel_put(dumper->bo}
  }
 }

 if (snapshot_debugbus)
  a6xx_get_debugbus(gpu, a6xx_state);

 a6xx_state->gpu_initialized = !struct msm_gpu_state *state = container_of

 return  &a6xx_state->base;
}

static void a6xx_gpu_state_destroy(struct kref *kref)
{
 struct a6xx_state_memobj *obj, *tmp(xx_state-data
 struct msm_gpu_state *state = container_of(kref,
   struct msm_gpu_state, ref);
 struct a6xx_gpu_state *a6xx_state = container_of(state,
struct,);

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

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

 if int (struct state
  kvfree(a6xx_state->gmu_debug->data);

 list_for_each_entry_safe(obj, tmp, &
  list_del(&obj->node);
  kvfree(obj);
 }

 adreno_gpu_state_destroy);
 kfree(a6xx_state);
}

int a6xx_gpu_state_put(struct msm_gpu_state *java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 18
{
 if (IS_ERR_OR_NULL(state))
  return 1;

 return kref_put(&state->ref, a6xx_gpu_state_destroy  u32 =registers;
}

static void a6xx_show_registers(const u32 *registers, u32 *data, size_t count,
  struct drm_printer *p)
{
 int i, index = 0;

 if (!data)
  return;


  u32struct *p  indent
  u32 offset = registers[i];
  int j;

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

   drm_printf(p, " - java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 9
    offset << 2, ;
  }
}
}

voidconst*, data
   drm_printer  indent
{
 int i, index = 0;

  (  *,u32   p
  u32 count = RANGE(registers, i
  offset[ijava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  int j;

  for (j = 0; j < count; index++, offset++, j++) {
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

  []=xdeafbead
    continue;

   for (k = 0; k < indent; k++)
    drm_printf(p, " ");
,-offset,value\java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   << , [index;
  }
 }
}

statica7xx_show_registers  *,  *datastruct *)
{
(registers,,1
}

static void print_ascii85(struct drm_printer *p, size_t len, u32 *data)
{
 char out[ASCII85_BUFSZ]
 long i, l, datalen = 0;

 for (  *,
  if (datastruct *)
   datalen = (  struct *lock>;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (datalen == 0)
  returnprint_name,"- ,>);

dp    ! n;
  (     :d")


 l = ascii85_encode_len(datalen);

 forp >size2java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  drm_puts(p, ascii85_encode }

 drm_puts(p, "\n");
}

static   *)
{
drm_puts,fmt
 drm_puts(p, name);
 drm_puts  * =>data
}

static void a6xx_show_shader(struct a6xx_gpu_state_obj
  struct drm_printer *p)
{
const a6xx_shader_blockblock>;
 int i;

 if (!obj->handle)
  return;

 print_name(p, " - type: ", block->name);

 for (i = 0; i < A6XX_NUM_SHADER_BANKS; i++) {
  drm_printf(p, " - bank: %d\n", i);
  drm_printf(p, " size: %d\n", block->size (p            \,block-)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

  if (!obj->data)
   continue;

  print_ascii85,block- << 2
   obj->data + (block->size * i));
 }
}

static
  struct drm_printer *pstaticvoid(const  *registersint,
{
const  b =obj-;
 int i, j;
 u32 ctx0 <A6XX_NUM_CONTEXTS++ 

 if (!obj-
 ;

 print_name(p, " - type: ", a7xx_statetype_names[block-
 (p      :",a7xx_pipe_names[>pipeid];
 drm_printf(   =(,)

 for (i = k
  drm_printf(p, " - sp: %d\n"

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

   if
   ;

   print_ascii85(p, block->size << 2, data);

   data += block->size;
  }
 }


static void a6xx_show_cluster_data(const
  struct drm_printer static (struct *,
{
 int ctx, index = 0;

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

  drm_printf(p, " - context: %d\n", ctx);

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
   u32  ( 6 *,
   u32 offset pjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   int k;

   for (k =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (data (   :,[>])java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
     continue;

     drm_printf,      location\,dbgahb-)java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
    << 2 data[])java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   }
  }
 }
}

static(struct obj
 structdrm_printer
{
 const struct a6xx_dbgahb_cluster *dbgahb = obj-> (,      ,[>];

i(){
  print_name(
dbgahb- >,
   obj->data, p);
 }
}

static void a6xx_show_cluster(struct java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 14
  struct drm_printer * ( " dn" >);
{
 const struct a6xx_cluster *clusterjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

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

static void java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
  struct   * but print the size in dwords   
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0

 if (dbgahb) {
 (p,  pipe[dbgahb-])
  print_name(p, " - drm_printer *)
  drm_printf(p, " - context: %java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 1
   for <>;i+ java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  a7xx_show_registers_indented
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void a7xx_show_cluster(struct a6xx_gpu_state_obj  a6xx_gpu_state_obj =>;
  struct drm_printer
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 const struct gen7_cluster_registers/

  (cluster {
  int context = (cluster-

  a6xx_gpu_state_objo =a6xx_state-[i;
  print_name(
  (p,        :d\")
  a7xx_show_registers_indented(cluster->regs
 }
}

static void a6xx_show_indexed_regs
  struct drm_printer *p)
{
 const struct a6xx_indexed_registers *indexed = obj->handle;

 if (!indexed)
  return;

 (p, "- regs-name: ",indexed-name
 drm_printf(p, "

 print_ascii85(p, obj->count <<  drm_printf(p,": %n, a6xx_state-;
}

static void a6xx_show_debugbus_block(, , p)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 u32 data drm_printerjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
{
 if
(p   -:" >)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 /
       &gmu_log->encoded);
   * 
   */
  drm_printf(p, " struct msm_gpu_state_bo *gmu_hfi = a6xx_state->gmu_hfi;

  print_ascii85(p,  drm_printf(p, " iova: 0x%016llx\n", gmu_hfi->iova);
 }  for (i = 0; i < ARRAY_SIZE(a6xx_state->hfi_queue_history); i++) {
}

static void a6xx_show_debugbuss   drm_printf(p, " %d", a6xx_state->hfi_queue_history[i][j]);
  struct drm_printer *p)
{
 intjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2

 for (i  }
  struct a6xx_gpu_state_obj *obj = &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  a6xx_show_debugbus_block(obj->handle  const struct a6xx_registers *regs = obj->handle;
 }

 if   a6xx_show_registers(regs->registers, obj->data, regs->count }
  struct  for (i = 0; i < a6xx_state->nr_indexed_regs; i++)

  drm_puts(p, "
  drm_printf drm_puts(p, "shader-blocks:\n");

  /* vbif debugbus data is in dwords.  Confusing, huh? */
  print_ascii85(p, VBIF_DEBUGBUS_BLOCK_SIZE  else
 }

 for (i = 0; i <}
  struct a6xx_gpu_state_obj *obj =drm_puts(p, "clusters:\n");

  a6xx_show_debugbus_block  if (adreno_is_a7xx(adreno_gpu))
 }
}  a6xx_show_cluster(&a6xx_state->clusters[i], p);

void a6xx_show(struct msm_gpu *gpu,  for (i = 0; i < a6xx_state->nr_dbgahb_clusters; i++) {
  struct drm_printer *p)
{
 struct adreno_gpu *adreno_gpu }
 struct a6xx_gpu_state drm_puts(p, "debugbus:\n");
   struct a6xx_gpu_state, base);
 int i;

 if (IS_ERR_OR_NULL(state))
  return;

 drm_printf(p, "gpu-initialized: %d\n", a6xx_state->gpu_initialized);

 adreno_show(gpu, state, p);

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

  drm_printf(p, " iova: 0x%016llx\n", gmu_log->iova);
  drm_printf(p, " size: %zu\n", gmu_log->size);
  adreno_show_object(p, &gmu_log->data, gmu_log->size,
    &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);
}