lisa/android_kernel_xiaomi_sm8350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ebb1a2799c
android_kernel_xiaomi_sm8350/msm/sde_dbg.c
Gopikrishnaiah Anandan 62e17c125b disp: msm: update debug dump for ltm block 
Local tone mapping hardware block has defined test points for debug bus.
Change updates the missing test points and enables dumping of the
registers in case of DPU hang.

Change-Id: I5bb5419255e84427c0a1393f8e9322b981eea084
Signed-off-by: Gopikrishnaiah Anandan <agopik@codeaurora.org>
2019-10-22 11:43:47 -07:00

4824 lines
115 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2009-2019, The Linux Foundation. All rights reserved.
*/
#define pr_fmt(fmt) "[drm:%s:%d] " fmt, __func__, __LINE__
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/ktime.h>
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/dma-buf.h>
#include <linux/slab.h>
#include <linux/list_sort.h>
#include <linux/pm.h>
#include <linux/pm_runtime.h>
#include "sde_dbg.h"
#include "sde/sde_hw_catalog.h"
#define SDE_DBG_BASE_MAX 10
#define DEFAULT_PANIC 1
#define DEFAULT_REGDUMP SDE_DBG_DUMP_IN_MEM
#define DEFAULT_DBGBUS_SDE SDE_DBG_DUMP_IN_MEM
#define DEFAULT_DBGBUS_VBIFRT SDE_DBG_DUMP_IN_MEM
#define DEFAULT_BASE_REG_CNT 0x100
#define GROUP_BYTES 4
#define ROW_BYTES 16
#define RANGE_NAME_LEN 40
#define REG_BASE_NAME_LEN 80
#define DBGBUS_FLAGS_DSPP BIT(0)
#define DBGBUS_DSPP_STATUS 0x34C
#define DBGBUS_NAME_SDE "sde"
#define DBGBUS_NAME_VBIF_RT "vbif_rt"
/* offsets from sde top address for the debug buses */
#define DBGBUS_SSPP0 0x188
#define DBGBUS_AXI_INTF 0x194
#define DBGBUS_SSPP1 0x298
#define DBGBUS_DSPP 0x348
#define DBGBUS_PERIPH 0x418
#define TEST_MASK(id, tp) ((id << 4) | (tp << 1) | BIT(0))
#define TEST_EXT_MASK(id, tp) (((tp >> 3) << 24) | (id << 4) \
| ((tp & 0x7) << 1) | BIT(0))
/* following offsets are with respect to MDP VBIF base for DBG BUS access */
#define MMSS_VBIF_CLKON 0x4
#define MMSS_VBIF_TEST_BUS_OUT_CTRL 0x210
#define MMSS_VBIF_TEST_BUS_OUT 0x230
/* Vbif error info */
#define MMSS_VBIF_PND_ERR 0x190
#define MMSS_VBIF_SRC_ERR 0x194
#define MMSS_VBIF_XIN_HALT_CTRL1 0x204
#define MMSS_VBIF_ERR_INFO 0X1a0
#define MMSS_VBIF_ERR_INFO_1 0x1a4
#define MMSS_VBIF_CLIENT_NUM 14
/* print debug ranges in groups of 4 u32s */
#define REG_DUMP_ALIGN 16
#define RSC_DEBUG_MUX_SEL_SDM845 9
#define DBG_CTRL_STOP_FTRACE BIT(0)
#define DBG_CTRL_PANIC_UNDERRUN BIT(1)
#define DBG_CTRL_RESET_HW_PANIC BIT(2)
#define DBG_CTRL_MAX BIT(3)
#define DUMP_BUF_SIZE (4096 * 512)
#define DUMP_CLMN_COUNT 4
#define DUMP_LINE_SIZE 256
#define DUMP_MAX_LINES_PER_BLK 512
/**
* struct sde_dbg_reg_offset - tracking for start and end of region
* @start: start offset
* @start: end offset
*/
struct sde_dbg_reg_offset {
u32 start;
u32 end;
};
/**
* struct sde_dbg_reg_range - register dumping named sub-range
* @head: head of this node
* @reg_dump: address for the mem dump
* @range_name: name of this range
* @offset: offsets for range to dump
* @xin_id: client xin id
*/
struct sde_dbg_reg_range {
struct list_head head;
u32 *reg_dump;
char range_name[RANGE_NAME_LEN];
struct sde_dbg_reg_offset offset;
uint32_t xin_id;
};
/**
* struct sde_dbg_reg_base - register region base.
* may sub-ranges: sub-ranges are used for dumping
* or may not have sub-ranges: dumping is base -> max_offset
* @reg_base_head: head of this node
* @sub_range_list: head to the list with dump ranges
* @name: register base name
* @base: base pointer
* @off: cached offset of region for manual register dumping
* @cnt: cached range of region for manual register dumping
* @max_offset: length of region
* @buf: buffer used for manual register dumping
* @buf_len: buffer length used for manual register dumping
* @reg_dump: address for the mem dump if no ranges used
* @cb: callback for external dump function, null if not defined
* @cb_ptr: private pointer to callback function
*/
struct sde_dbg_reg_base {
struct list_head reg_base_head;
struct list_head sub_range_list;
char name[REG_BASE_NAME_LEN];
void __iomem *base;
size_t off;
size_t cnt;
size_t max_offset;
char *buf;
size_t buf_len;
u32 *reg_dump;
void (*cb)(void *ptr);
void *cb_ptr;
};
struct sde_debug_bus_entry {
u32 wr_addr;
u32 block_id;
u32 test_id;
void (*analyzer)(void __iomem *mem_base,
struct sde_debug_bus_entry *entry, u32 val);
};
struct vbif_debug_bus_entry {
u32 disable_bus_addr;
u32 block_bus_addr;
u32 bit_offset;
u32 block_cnt;
u32 test_pnt_start;
u32 test_pnt_cnt;
};
struct sde_dbg_debug_bus_common {
char *name;
u32 enable_mask;
bool include_in_deferred_work;
u32 flags;
u32 entries_size;
u32 *dumped_content;
};
struct sde_dbg_sde_debug_bus {
struct sde_dbg_debug_bus_common cmn;
struct sde_debug_bus_entry *entries;
u32 top_blk_off;
};
struct sde_dbg_vbif_debug_bus {
struct sde_dbg_debug_bus_common cmn;
struct vbif_debug_bus_entry *entries;
};
struct sde_dbg_dsi_debug_bus {
u32 *entries;
u32 size;
};
/**
* struct sde_dbg_regbuf - wraps buffer and tracking params for register dumps
* @buf: pointer to allocated memory for storing register dumps in hw recovery
* @buf_size: size of the memory allocated
* @len: size of the dump data valid in the buffer
* @rpos: cursor points to the buffer position read by client
* @dump_done: to indicate if dumping to user memory is complete
* @cur_blk: points to the current sde_dbg_reg_base block
*/
struct sde_dbg_regbuf {
char *buf;
int buf_size;
int len;
int rpos;
int dump_done;
struct sde_dbg_reg_base *cur_blk;
};
/**
* struct sde_dbg_base - global sde debug base structure
* @evtlog: event log instance
* @reg_base_list: list of register dumping regions
* @dev: device pointer
* @mutex: mutex to serialize access to serialze dumps, debugfs access
* @req_dump_blks: list of blocks requested for dumping
* @panic_on_err: whether to kernel panic after triggering dump via debugfs
* @dump_work: work struct for deferring register dump work to separate thread
* @work_panic: panic after dump if internal user passed "panic" special region
* @enable_reg_dump: whether to dump registers into memory, kernel log, or both
* @dbgbus_sde: debug bus structure for the sde
* @dbgbus_vbif_rt: debug bus structure for the realtime vbif
* @dump_all: dump all entries in register dump
* @dump_secure: dump entries excluding few as it is in secure-session
* @dsi_dbg_bus: dump dsi debug bus register
* @regbuf: buffer data to track the register dumping in hw recovery
* @cur_evt_index: index used for tracking event logs dump in hw recovery
* @dbgbus_dump_idx: index used for tracking dbg-bus dump in hw recovery
* @vbif_dbgbus_dump_idx: index for tracking vbif dumps in hw recovery
*/
static struct sde_dbg_base {
struct sde_dbg_evtlog *evtlog;
struct list_head reg_base_list;
struct device *dev;
struct mutex mutex;
struct sde_dbg_reg_base *req_dump_blks[SDE_DBG_BASE_MAX];
u32 panic_on_err;
struct work_struct dump_work;
bool work_panic;
u32 enable_reg_dump;
struct sde_dbg_sde_debug_bus dbgbus_sde;
struct sde_dbg_vbif_debug_bus dbgbus_vbif_rt;
struct sde_dbg_dsi_debug_bus dbgbus_dsi;
bool dump_all;
bool dump_secure;
bool dsi_dbg_bus;
u32 debugfs_ctrl;
struct sde_dbg_regbuf regbuf;
u32 cur_evt_index;
u32 dbgbus_dump_idx;
u32 vbif_dbgbus_dump_idx;
enum sde_dbg_dump_context dump_mode;
} sde_dbg_base;
/* sde_dbg_base_evtlog - global pointer to main sde event log for macro use */
struct sde_dbg_evtlog *sde_dbg_base_evtlog;
static void _sde_debug_bus_xbar_dump(void __iomem *mem_base,
struct sde_debug_bus_entry *entry, u32 val)
{
dev_err(sde_dbg_base.dev, "xbar 0x%x %d %d 0x%x\n",
entry->wr_addr, entry->block_id, entry->test_id, val);
}
static void _sde_debug_bus_lm_dump(void __iomem *mem_base,
struct sde_debug_bus_entry *entry, u32 val)
{
if (!(val & 0xFFF000))
return;
dev_err(sde_dbg_base.dev, "lm 0x%x %d %d 0x%x\n",
entry->wr_addr, entry->block_id, entry->test_id, val);
}
static void _sde_debug_bus_ppb0_dump(void __iomem *mem_base,
struct sde_debug_bus_entry *entry, u32 val)
{
if (!(val & BIT(15)))
return;
dev_err(sde_dbg_base.dev, "ppb0 0x%x %d %d 0x%x\n",
entry->wr_addr, entry->block_id, entry->test_id, val);
}
static void _sde_debug_bus_ltm_dump(void __iomem *mem_base,
struct sde_debug_bus_entry *entry, u32 val)
{
dev_info(sde_dbg_base.dev, "ltm 0x%x %d %d 0x%x\n",
entry->wr_addr, entry->block_id, entry->test_id, val);
}
static void _sde_debug_bus_ppb1_dump(void __iomem *mem_base,
struct sde_debug_bus_entry *entry, u32 val)
{
if (!(val & BIT(15)))
return;
dev_err(sde_dbg_base.dev, "ppb1 0x%x %d %d 0x%x\n",
entry->wr_addr, entry->block_id, entry->test_id, val);
}
static struct sde_debug_bus_entry dbg_bus_sde_sm8150[] = {
/* Unpack 0 sspp 0*/
{ DBGBUS_SSPP0, 35, 2 },
{ DBGBUS_SSPP0, 50, 2 },
{ DBGBUS_SSPP0, 60, 2 },
{ DBGBUS_SSPP0, 70, 2 },
/* Unpack 1 sspp 0*/
{ DBGBUS_SSPP0, 36, 2 },
{ DBGBUS_SSPP0, 51, 2 },
{ DBGBUS_SSPP0, 61, 2 },
{ DBGBUS_SSPP0, 71, 2 },
/* Unpack 2 sspp 0*/
{ DBGBUS_SSPP0, 37, 2 },
{ DBGBUS_SSPP0, 52, 2 },
{ DBGBUS_SSPP0, 62, 2 },
{ DBGBUS_SSPP0, 72, 2 },
/* Unpack 3 sspp 0*/
{ DBGBUS_SSPP0, 38, 2 },
{ DBGBUS_SSPP0, 53, 2 },
{ DBGBUS_SSPP0, 63, 2 },
{ DBGBUS_SSPP0, 73, 2 },
/* Unpack 0 sspp 1*/
{ DBGBUS_SSPP1, 35, 2 },
{ DBGBUS_SSPP1, 50, 2 },
{ DBGBUS_SSPP1, 60, 2 },
{ DBGBUS_SSPP1, 70, 2 },
/* Unpack 1 sspp 1*/
{ DBGBUS_SSPP1, 36, 2 },
{ DBGBUS_SSPP1, 51, 2 },
{ DBGBUS_SSPP1, 61, 2 },
{ DBGBUS_SSPP1, 71, 2 },
/* Unpack 2 sspp 1*/
{ DBGBUS_SSPP1, 37, 2 },
{ DBGBUS_SSPP1, 52, 2 },
{ DBGBUS_SSPP1, 62, 2 },
{ DBGBUS_SSPP1, 72, 2 },
/* Unpack 3 sspp 1*/
{ DBGBUS_SSPP1, 38, 2 },
{ DBGBUS_SSPP1, 53, 2 },
{ DBGBUS_SSPP1, 63, 2 },
{ DBGBUS_SSPP1, 73, 2 },
/* scheduler */
{ DBGBUS_DSPP, 130, 0 },
{ DBGBUS_DSPP, 130, 1 },
{ DBGBUS_DSPP, 130, 2 },
{ DBGBUS_DSPP, 130, 3 },
{ DBGBUS_DSPP, 130, 4 },
{ DBGBUS_DSPP, 130, 5 },
/* fetch sspp0 */
/* vig 0 */
{ DBGBUS_SSPP0, 0, 0 },
{ DBGBUS_SSPP0, 0, 1 },
{ DBGBUS_SSPP0, 0, 2 },
{ DBGBUS_SSPP0, 0, 3 },
{ DBGBUS_SSPP0, 0, 4 },
{ DBGBUS_SSPP0, 0, 5 },
{ DBGBUS_SSPP0, 0, 6 },
{ DBGBUS_SSPP0, 0, 7 },
{ DBGBUS_SSPP0, 1, 0 },
{ DBGBUS_SSPP0, 1, 1 },
{ DBGBUS_SSPP0, 1, 2 },
{ DBGBUS_SSPP0, 1, 3 },
{ DBGBUS_SSPP0, 1, 4 },
{ DBGBUS_SSPP0, 1, 5 },
{ DBGBUS_SSPP0, 1, 6 },
{ DBGBUS_SSPP0, 1, 7 },
{ DBGBUS_SSPP0, 2, 0 },
{ DBGBUS_SSPP0, 2, 1 },
{ DBGBUS_SSPP0, 2, 2 },
{ DBGBUS_SSPP0, 2, 3 },
{ DBGBUS_SSPP0, 2, 4 },
{ DBGBUS_SSPP0, 2, 5 },
{ DBGBUS_SSPP0, 2, 6 },
{ DBGBUS_SSPP0, 2, 7 },
{ DBGBUS_SSPP0, 4, 0 },
{ DBGBUS_SSPP0, 4, 1 },
{ DBGBUS_SSPP0, 4, 2 },
{ DBGBUS_SSPP0, 4, 3 },
{ DBGBUS_SSPP0, 4, 4 },
{ DBGBUS_SSPP0, 4, 5 },
{ DBGBUS_SSPP0, 4, 6 },
{ DBGBUS_SSPP0, 4, 7 },
{ DBGBUS_SSPP0, 5, 0 },
{ DBGBUS_SSPP0, 5, 1 },
{ DBGBUS_SSPP0, 5, 2 },
{ DBGBUS_SSPP0, 5, 3 },
{ DBGBUS_SSPP0, 5, 4 },
{ DBGBUS_SSPP0, 5, 5 },
{ DBGBUS_SSPP0, 5, 6 },
{ DBGBUS_SSPP0, 5, 7 },
/* vig 2 */
{ DBGBUS_SSPP0, 20, 0 },
{ DBGBUS_SSPP0, 20, 1 },
{ DBGBUS_SSPP0, 20, 2 },
{ DBGBUS_SSPP0, 20, 3 },
{ DBGBUS_SSPP0, 20, 4 },
{ DBGBUS_SSPP0, 20, 5 },
{ DBGBUS_SSPP0, 20, 6 },
{ DBGBUS_SSPP0, 20, 7 },
{ DBGBUS_SSPP0, 21, 0 },
{ DBGBUS_SSPP0, 21, 1 },
{ DBGBUS_SSPP0, 21, 2 },
{ DBGBUS_SSPP0, 21, 3 },
{ DBGBUS_SSPP0, 21, 4 },
{ DBGBUS_SSPP0, 21, 5 },
{ DBGBUS_SSPP0, 21, 6 },
{ DBGBUS_SSPP0, 21, 7 },
{ DBGBUS_SSPP0, 22, 0 },
{ DBGBUS_SSPP0, 22, 1 },
{ DBGBUS_SSPP0, 22, 2 },
{ DBGBUS_SSPP0, 22, 3 },
{ DBGBUS_SSPP0, 22, 4 },
{ DBGBUS_SSPP0, 22, 5 },
{ DBGBUS_SSPP0, 22, 6 },
{ DBGBUS_SSPP0, 22, 7 },
{ DBGBUS_SSPP0, 24, 0 },
{ DBGBUS_SSPP0, 24, 1 },
{ DBGBUS_SSPP0, 24, 2 },
{ DBGBUS_SSPP0, 24, 3 },
{ DBGBUS_SSPP0, 24, 4 },
{ DBGBUS_SSPP0, 24, 5 },
{ DBGBUS_SSPP0, 24, 6 },
{ DBGBUS_SSPP0, 24, 7 },
{ DBGBUS_SSPP0, 25, 0 },
{ DBGBUS_SSPP0, 25, 1 },
{ DBGBUS_SSPP0, 25, 2 },
{ DBGBUS_SSPP0, 25, 3 },
{ DBGBUS_SSPP0, 25, 4 },
{ DBGBUS_SSPP0, 25, 5 },
{ DBGBUS_SSPP0, 25, 6 },
{ DBGBUS_SSPP0, 25, 7 },
/* dma 2 */
{ DBGBUS_SSPP0, 30, 0 },
{ DBGBUS_SSPP0, 30, 1 },
{ DBGBUS_SSPP0, 30, 2 },
{ DBGBUS_SSPP0, 30, 3 },
{ DBGBUS_SSPP0, 30, 4 },
{ DBGBUS_SSPP0, 30, 5 },
{ DBGBUS_SSPP0, 30, 6 },
{ DBGBUS_SSPP0, 30, 7 },
{ DBGBUS_SSPP0, 31, 0 },
{ DBGBUS_SSPP0, 31, 1 },
{ DBGBUS_SSPP0, 31, 2 },
{ DBGBUS_SSPP0, 31, 3 },
{ DBGBUS_SSPP0, 31, 4 },
{ DBGBUS_SSPP0, 31, 5 },
{ DBGBUS_SSPP0, 31, 6 },
{ DBGBUS_SSPP0, 31, 7 },
{ DBGBUS_SSPP0, 32, 0 },
{ DBGBUS_SSPP0, 32, 1 },
{ DBGBUS_SSPP0, 32, 2 },
{ DBGBUS_SSPP0, 32, 3 },
{ DBGBUS_SSPP0, 32, 4 },
{ DBGBUS_SSPP0, 32, 5 },
{ DBGBUS_SSPP0, 32, 6 },
{ DBGBUS_SSPP0, 32, 7 },
{ DBGBUS_SSPP0, 33, 0 },
{ DBGBUS_SSPP0, 33, 1 },
{ DBGBUS_SSPP0, 33, 2 },
{ DBGBUS_SSPP0, 33, 3 },
{ DBGBUS_SSPP0, 33, 4 },
{ DBGBUS_SSPP0, 33, 5 },
{ DBGBUS_SSPP0, 33, 6 },
{ DBGBUS_SSPP0, 33, 7 },
{ DBGBUS_SSPP0, 34, 0 },
{ DBGBUS_SSPP0, 34, 1 },
{ DBGBUS_SSPP0, 34, 2 },
{ DBGBUS_SSPP0, 34, 3 },
{ DBGBUS_SSPP0, 34, 4 },
{ DBGBUS_SSPP0, 34, 5 },
{ DBGBUS_SSPP0, 34, 6 },
{ DBGBUS_SSPP0, 34, 7 },
/* dma 0 */
{ DBGBUS_SSPP0, 40, 0 },
{ DBGBUS_SSPP0, 40, 1 },
{ DBGBUS_SSPP0, 40, 2 },
{ DBGBUS_SSPP0, 40, 3 },
{ DBGBUS_SSPP0, 40, 4 },
{ DBGBUS_SSPP0, 40, 5 },
{ DBGBUS_SSPP0, 40, 6 },
{ DBGBUS_SSPP0, 40, 7 },
{ DBGBUS_SSPP0, 41, 0 },
{ DBGBUS_SSPP0, 41, 1 },
{ DBGBUS_SSPP0, 41, 2 },
{ DBGBUS_SSPP0, 41, 3 },
{ DBGBUS_SSPP0, 41, 4 },
{ DBGBUS_SSPP0, 41, 5 },
{ DBGBUS_SSPP0, 41, 6 },
{ DBGBUS_SSPP0, 41, 7 },
{ DBGBUS_SSPP0, 42, 0 },
{ DBGBUS_SSPP0, 42, 1 },
{ DBGBUS_SSPP0, 42, 2 },
{ DBGBUS_SSPP0, 42, 3 },
{ DBGBUS_SSPP0, 42, 4 },
{ DBGBUS_SSPP0, 42, 5 },
{ DBGBUS_SSPP0, 42, 6 },
{ DBGBUS_SSPP0, 42, 7 },
{ DBGBUS_SSPP0, 44, 0 },
{ DBGBUS_SSPP0, 44, 1 },
{ DBGBUS_SSPP0, 44, 2 },
{ DBGBUS_SSPP0, 44, 3 },
{ DBGBUS_SSPP0, 44, 4 },
{ DBGBUS_SSPP0, 44, 5 },
{ DBGBUS_SSPP0, 44, 6 },
{ DBGBUS_SSPP0, 44, 7 },
{ DBGBUS_SSPP0, 45, 0 },
{ DBGBUS_SSPP0, 45, 1 },
{ DBGBUS_SSPP0, 45, 2 },
{ DBGBUS_SSPP0, 45, 3 },
{ DBGBUS_SSPP0, 45, 4 },
{ DBGBUS_SSPP0, 45, 5 },
{ DBGBUS_SSPP0, 45, 6 },
{ DBGBUS_SSPP0, 45, 7 },
/* fetch sspp1 */
/* vig 1 */
{ DBGBUS_SSPP1, 0, 0 },
{ DBGBUS_SSPP1, 0, 1 },
{ DBGBUS_SSPP1, 0, 2 },
{ DBGBUS_SSPP1, 0, 3 },
{ DBGBUS_SSPP1, 0, 4 },
{ DBGBUS_SSPP1, 0, 5 },
{ DBGBUS_SSPP1, 0, 6 },
{ DBGBUS_SSPP1, 0, 7 },
{ DBGBUS_SSPP1, 1, 0 },
{ DBGBUS_SSPP1, 1, 1 },
{ DBGBUS_SSPP1, 1, 2 },
{ DBGBUS_SSPP1, 1, 3 },
{ DBGBUS_SSPP1, 1, 4 },
{ DBGBUS_SSPP1, 1, 5 },
{ DBGBUS_SSPP1, 1, 6 },
{ DBGBUS_SSPP1, 1, 7 },
{ DBGBUS_SSPP1, 2, 0 },
{ DBGBUS_SSPP1, 2, 1 },
{ DBGBUS_SSPP1, 2, 2 },
{ DBGBUS_SSPP1, 2, 3 },
{ DBGBUS_SSPP1, 2, 4 },
{ DBGBUS_SSPP1, 2, 5 },
{ DBGBUS_SSPP1, 2, 6 },
{ DBGBUS_SSPP1, 2, 7 },
{ DBGBUS_SSPP1, 4, 0 },
{ DBGBUS_SSPP1, 4, 1 },
{ DBGBUS_SSPP1, 4, 2 },
{ DBGBUS_SSPP1, 4, 3 },
{ DBGBUS_SSPP1, 4, 4 },
{ DBGBUS_SSPP1, 4, 5 },
{ DBGBUS_SSPP1, 4, 6 },
{ DBGBUS_SSPP1, 4, 7 },
{ DBGBUS_SSPP1, 5, 0 },
{ DBGBUS_SSPP1, 5, 1 },
{ DBGBUS_SSPP1, 5, 2 },
{ DBGBUS_SSPP1, 5, 3 },
{ DBGBUS_SSPP1, 5, 4 },
{ DBGBUS_SSPP1, 5, 5 },
{ DBGBUS_SSPP1, 5, 6 },
{ DBGBUS_SSPP1, 5, 7 },
/* vig 3 */
{ DBGBUS_SSPP1, 20, 0 },
{ DBGBUS_SSPP1, 20, 1 },
{ DBGBUS_SSPP1, 20, 2 },
{ DBGBUS_SSPP1, 20, 3 },
{ DBGBUS_SSPP1, 20, 4 },
{ DBGBUS_SSPP1, 20, 5 },
{ DBGBUS_SSPP1, 20, 6 },
{ DBGBUS_SSPP1, 20, 7 },
{ DBGBUS_SSPP1, 21, 0 },
{ DBGBUS_SSPP1, 21, 1 },
{ DBGBUS_SSPP1, 21, 2 },
{ DBGBUS_SSPP1, 21, 3 },
{ DBGBUS_SSPP1, 21, 4 },
{ DBGBUS_SSPP1, 21, 5 },
{ DBGBUS_SSPP1, 21, 6 },
{ DBGBUS_SSPP1, 21, 7 },
{ DBGBUS_SSPP1, 22, 0 },
{ DBGBUS_SSPP1, 22, 1 },
{ DBGBUS_SSPP1, 22, 2 },
{ DBGBUS_SSPP1, 22, 3 },
{ DBGBUS_SSPP1, 22, 4 },
{ DBGBUS_SSPP1, 22, 5 },
{ DBGBUS_SSPP1, 22, 6 },
{ DBGBUS_SSPP1, 22, 7 },
{ DBGBUS_SSPP1, 24, 0 },
{ DBGBUS_SSPP1, 24, 1 },
{ DBGBUS_SSPP1, 24, 2 },
{ DBGBUS_SSPP1, 24, 3 },
{ DBGBUS_SSPP1, 24, 4 },
{ DBGBUS_SSPP1, 24, 5 },
{ DBGBUS_SSPP1, 24, 6 },
{ DBGBUS_SSPP1, 24, 7 },
{ DBGBUS_SSPP1, 25, 0 },
{ DBGBUS_SSPP1, 25, 1 },
{ DBGBUS_SSPP1, 25, 2 },
{ DBGBUS_SSPP1, 25, 3 },
{ DBGBUS_SSPP1, 25, 4 },
{ DBGBUS_SSPP1, 25, 5 },
{ DBGBUS_SSPP1, 25, 6 },
{ DBGBUS_SSPP1, 25, 7 },
/* dma 3 */
{ DBGBUS_SSPP1, 30, 0 },
{ DBGBUS_SSPP1, 30, 1 },
{ DBGBUS_SSPP1, 30, 2 },
{ DBGBUS_SSPP1, 30, 3 },
{ DBGBUS_SSPP1, 30, 4 },
{ DBGBUS_SSPP1, 30, 5 },
{ DBGBUS_SSPP1, 30, 6 },
{ DBGBUS_SSPP1, 30, 7 },
{ DBGBUS_SSPP1, 31, 0 },
{ DBGBUS_SSPP1, 31, 1 },
{ DBGBUS_SSPP1, 31, 2 },
{ DBGBUS_SSPP1, 31, 3 },
{ DBGBUS_SSPP1, 31, 4 },
{ DBGBUS_SSPP1, 31, 5 },
{ DBGBUS_SSPP1, 31, 6 },
{ DBGBUS_SSPP1, 31, 7 },
{ DBGBUS_SSPP1, 32, 0 },
{ DBGBUS_SSPP1, 32, 1 },
{ DBGBUS_SSPP1, 32, 2 },
{ DBGBUS_SSPP1, 32, 3 },
{ DBGBUS_SSPP1, 32, 4 },
{ DBGBUS_SSPP1, 32, 5 },
{ DBGBUS_SSPP1, 32, 6 },
{ DBGBUS_SSPP1, 32, 7 },
{ DBGBUS_SSPP1, 33, 0 },
{ DBGBUS_SSPP1, 33, 1 },
{ DBGBUS_SSPP1, 33, 2 },
{ DBGBUS_SSPP1, 33, 3 },
{ DBGBUS_SSPP1, 33, 4 },
{ DBGBUS_SSPP1, 33, 5 },
{ DBGBUS_SSPP1, 33, 6 },
{ DBGBUS_SSPP1, 33, 7 },
{ DBGBUS_SSPP1, 34, 0 },
{ DBGBUS_SSPP1, 34, 1 },
{ DBGBUS_SSPP1, 34, 2 },
{ DBGBUS_SSPP1, 34, 3 },
{ DBGBUS_SSPP1, 34, 4 },
{ DBGBUS_SSPP1, 34, 5 },
{ DBGBUS_SSPP1, 34, 6 },
{ DBGBUS_SSPP1, 34, 7 },
/* dma 1 */
{ DBGBUS_SSPP1, 40, 0 },
{ DBGBUS_SSPP1, 40, 1 },
{ DBGBUS_SSPP1, 40, 2 },
{ DBGBUS_SSPP1, 40, 3 },
{ DBGBUS_SSPP1, 40, 4 },
{ DBGBUS_SSPP1, 40, 5 },
{ DBGBUS_SSPP1, 40, 6 },
{ DBGBUS_SSPP1, 40, 7 },
{ DBGBUS_SSPP1, 41, 0 },
{ DBGBUS_SSPP1, 41, 1 },
{ DBGBUS_SSPP1, 41, 2 },
{ DBGBUS_SSPP1, 41, 3 },
{ DBGBUS_SSPP1, 41, 4 },
{ DBGBUS_SSPP1, 41, 5 },
{ DBGBUS_SSPP1, 41, 6 },
{ DBGBUS_SSPP1, 41, 7 },
{ DBGBUS_SSPP1, 42, 0 },
{ DBGBUS_SSPP1, 42, 1 },
{ DBGBUS_SSPP1, 42, 2 },
{ DBGBUS_SSPP1, 42, 3 },
{ DBGBUS_SSPP1, 42, 4 },
{ DBGBUS_SSPP1, 42, 5 },
{ DBGBUS_SSPP1, 42, 6 },
{ DBGBUS_SSPP1, 42, 7 },
{ DBGBUS_SSPP1, 44, 0 },
{ DBGBUS_SSPP1, 44, 1 },
{ DBGBUS_SSPP1, 44, 2 },
{ DBGBUS_SSPP1, 44, 3 },
{ DBGBUS_SSPP1, 44, 4 },
{ DBGBUS_SSPP1, 44, 5 },
{ DBGBUS_SSPP1, 44, 6 },
{ DBGBUS_SSPP1, 44, 7 },
{ DBGBUS_SSPP1, 45, 0 },
{ DBGBUS_SSPP1, 45, 1 },
{ DBGBUS_SSPP1, 45, 2 },
{ DBGBUS_SSPP1, 45, 3 },
{ DBGBUS_SSPP1, 45, 4 },
{ DBGBUS_SSPP1, 45, 5 },
{ DBGBUS_SSPP1, 45, 6 },
{ DBGBUS_SSPP1, 45, 7 },
/* ppb_0 */
{ DBGBUS_DSPP, 31, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 33, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 35, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 42, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 47, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 49, 0, _sde_debug_bus_ppb0_dump },
/* ppb_1 */
{ DBGBUS_DSPP, 32, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 34, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 36, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 43, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 48, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 50, 0, _sde_debug_bus_ppb1_dump },
/* crossbar */
{ DBGBUS_DSPP, 0, 0, _sde_debug_bus_xbar_dump },
/* rotator */
{ DBGBUS_DSPP, 9, 0},
/* blend */
/* LM0 */
{ DBGBUS_DSPP, 63, 1},
{ DBGBUS_DSPP, 63, 2},
{ DBGBUS_DSPP, 63, 3},
{ DBGBUS_DSPP, 63, 4},
{ DBGBUS_DSPP, 63, 5},
{ DBGBUS_DSPP, 63, 6},
{ DBGBUS_DSPP, 63, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 64, 1},
{ DBGBUS_DSPP, 64, 2},
{ DBGBUS_DSPP, 64, 3},
{ DBGBUS_DSPP, 64, 4},
{ DBGBUS_DSPP, 64, 5},
{ DBGBUS_DSPP, 64, 6},
{ DBGBUS_DSPP, 64, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 65, 1},
{ DBGBUS_DSPP, 65, 2},
{ DBGBUS_DSPP, 65, 3},
{ DBGBUS_DSPP, 65, 4},
{ DBGBUS_DSPP, 65, 5},
{ DBGBUS_DSPP, 65, 6},
{ DBGBUS_DSPP, 65, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 66, 1},
{ DBGBUS_DSPP, 66, 2},
{ DBGBUS_DSPP, 66, 3},
{ DBGBUS_DSPP, 66, 4},
{ DBGBUS_DSPP, 66, 5},
{ DBGBUS_DSPP, 66, 6},
{ DBGBUS_DSPP, 66, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 67, 1},
{ DBGBUS_DSPP, 67, 2},
{ DBGBUS_DSPP, 67, 3},
{ DBGBUS_DSPP, 67, 4},
{ DBGBUS_DSPP, 67, 5},
{ DBGBUS_DSPP, 67, 6},
{ DBGBUS_DSPP, 67, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 68, 1},
{ DBGBUS_DSPP, 68, 2},
{ DBGBUS_DSPP, 68, 3},
{ DBGBUS_DSPP, 68, 4},
{ DBGBUS_DSPP, 68, 5},
{ DBGBUS_DSPP, 68, 6},
{ DBGBUS_DSPP, 68, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 69, 1},
{ DBGBUS_DSPP, 69, 2},
{ DBGBUS_DSPP, 69, 3},
{ DBGBUS_DSPP, 69, 4},
{ DBGBUS_DSPP, 69, 5},
{ DBGBUS_DSPP, 69, 6},
{ DBGBUS_DSPP, 69, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 84, 1},
{ DBGBUS_DSPP, 84, 2},
{ DBGBUS_DSPP, 84, 3},
{ DBGBUS_DSPP, 84, 4},
{ DBGBUS_DSPP, 84, 5},
{ DBGBUS_DSPP, 84, 6},
{ DBGBUS_DSPP, 84, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 85, 1},
{ DBGBUS_DSPP, 85, 2},
{ DBGBUS_DSPP, 85, 3},
{ DBGBUS_DSPP, 85, 4},
{ DBGBUS_DSPP, 85, 5},
{ DBGBUS_DSPP, 85, 6},
{ DBGBUS_DSPP, 85, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 86, 1},
{ DBGBUS_DSPP, 86, 2},
{ DBGBUS_DSPP, 86, 3},
{ DBGBUS_DSPP, 86, 4},
{ DBGBUS_DSPP, 86, 5},
{ DBGBUS_DSPP, 86, 6},
{ DBGBUS_DSPP, 86, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 87, 1},
{ DBGBUS_DSPP, 87, 2},
{ DBGBUS_DSPP, 87, 3},
{ DBGBUS_DSPP, 87, 4},
{ DBGBUS_DSPP, 87, 5},
{ DBGBUS_DSPP, 87, 6},
{ DBGBUS_DSPP, 87, 7, _sde_debug_bus_lm_dump },
/* LM1 */
{ DBGBUS_DSPP, 70, 1},
{ DBGBUS_DSPP, 70, 2},
{ DBGBUS_DSPP, 70, 3},
{ DBGBUS_DSPP, 70, 4},
{ DBGBUS_DSPP, 70, 5},
{ DBGBUS_DSPP, 70, 6},
{ DBGBUS_DSPP, 70, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 71, 1},
{ DBGBUS_DSPP, 71, 2},
{ DBGBUS_DSPP, 71, 3},
{ DBGBUS_DSPP, 71, 4},
{ DBGBUS_DSPP, 71, 5},
{ DBGBUS_DSPP, 71, 6},
{ DBGBUS_DSPP, 71, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 72, 1},
{ DBGBUS_DSPP, 72, 2},
{ DBGBUS_DSPP, 72, 3},
{ DBGBUS_DSPP, 72, 4},
{ DBGBUS_DSPP, 72, 5},
{ DBGBUS_DSPP, 72, 6},
{ DBGBUS_DSPP, 72, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 73, 1},
{ DBGBUS_DSPP, 73, 2},
{ DBGBUS_DSPP, 73, 3},
{ DBGBUS_DSPP, 73, 4},
{ DBGBUS_DSPP, 73, 5},
{ DBGBUS_DSPP, 73, 6},
{ DBGBUS_DSPP, 73, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 74, 1},
{ DBGBUS_DSPP, 74, 2},
{ DBGBUS_DSPP, 74, 3},
{ DBGBUS_DSPP, 74, 4},
{ DBGBUS_DSPP, 74, 5},
{ DBGBUS_DSPP, 74, 6},
{ DBGBUS_DSPP, 74, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 75, 1},
{ DBGBUS_DSPP, 75, 2},
{ DBGBUS_DSPP, 75, 3},
{ DBGBUS_DSPP, 75, 4},
{ DBGBUS_DSPP, 75, 5},
{ DBGBUS_DSPP, 75, 6},
{ DBGBUS_DSPP, 75, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 76, 1},
{ DBGBUS_DSPP, 76, 2},
{ DBGBUS_DSPP, 76, 3},
{ DBGBUS_DSPP, 76, 4},
{ DBGBUS_DSPP, 76, 5},
{ DBGBUS_DSPP, 76, 6},
{ DBGBUS_DSPP, 76, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 88, 1},
{ DBGBUS_DSPP, 88, 2},
{ DBGBUS_DSPP, 88, 3},
{ DBGBUS_DSPP, 88, 4},
{ DBGBUS_DSPP, 88, 5},
{ DBGBUS_DSPP, 88, 6},
{ DBGBUS_DSPP, 88, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 89, 1},
{ DBGBUS_DSPP, 89, 2},
{ DBGBUS_DSPP, 89, 3},
{ DBGBUS_DSPP, 89, 4},
{ DBGBUS_DSPP, 89, 5},
{ DBGBUS_DSPP, 89, 6},
{ DBGBUS_DSPP, 89, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 90, 1},
{ DBGBUS_DSPP, 90, 2},
{ DBGBUS_DSPP, 90, 3},
{ DBGBUS_DSPP, 90, 4},
{ DBGBUS_DSPP, 90, 5},
{ DBGBUS_DSPP, 90, 6},
{ DBGBUS_DSPP, 90, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 91, 1},
{ DBGBUS_DSPP, 91, 2},
{ DBGBUS_DSPP, 91, 3},
{ DBGBUS_DSPP, 91, 4},
{ DBGBUS_DSPP, 91, 5},
{ DBGBUS_DSPP, 91, 6},
{ DBGBUS_DSPP, 91, 7, _sde_debug_bus_lm_dump },
/* LM2 */
{ DBGBUS_DSPP, 77, 0},
{ DBGBUS_DSPP, 77, 1},
{ DBGBUS_DSPP, 77, 2},
{ DBGBUS_DSPP, 77, 3},
{ DBGBUS_DSPP, 77, 4},
{ DBGBUS_DSPP, 77, 5},
{ DBGBUS_DSPP, 77, 6},
{ DBGBUS_DSPP, 77, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 78, 0},
{ DBGBUS_DSPP, 78, 1},
{ DBGBUS_DSPP, 78, 2},
{ DBGBUS_DSPP, 78, 3},
{ DBGBUS_DSPP, 78, 4},
{ DBGBUS_DSPP, 78, 5},
{ DBGBUS_DSPP, 78, 6},
{ DBGBUS_DSPP, 78, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 79, 0},
{ DBGBUS_DSPP, 79, 1},
{ DBGBUS_DSPP, 79, 2},
{ DBGBUS_DSPP, 79, 3},
{ DBGBUS_DSPP, 79, 4},
{ DBGBUS_DSPP, 79, 5},
{ DBGBUS_DSPP, 79, 6},
{ DBGBUS_DSPP, 79, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 80, 0},
{ DBGBUS_DSPP, 80, 1},
{ DBGBUS_DSPP, 80, 2},
{ DBGBUS_DSPP, 80, 3},
{ DBGBUS_DSPP, 80, 4},
{ DBGBUS_DSPP, 80, 5},
{ DBGBUS_DSPP, 80, 6},
{ DBGBUS_DSPP, 80, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 81, 0},
{ DBGBUS_DSPP, 81, 1},
{ DBGBUS_DSPP, 81, 2},
{ DBGBUS_DSPP, 81, 3},
{ DBGBUS_DSPP, 81, 4},
{ DBGBUS_DSPP, 81, 5},
{ DBGBUS_DSPP, 81, 6},
{ DBGBUS_DSPP, 81, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 82, 0},
{ DBGBUS_DSPP, 82, 1},
{ DBGBUS_DSPP, 82, 2},
{ DBGBUS_DSPP, 82, 3},
{ DBGBUS_DSPP, 82, 4},
{ DBGBUS_DSPP, 82, 5},
{ DBGBUS_DSPP, 82, 6},
{ DBGBUS_DSPP, 82, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 83, 0},
{ DBGBUS_DSPP, 83, 1},
{ DBGBUS_DSPP, 83, 2},
{ DBGBUS_DSPP, 83, 3},
{ DBGBUS_DSPP, 83, 4},
{ DBGBUS_DSPP, 83, 5},
{ DBGBUS_DSPP, 83, 6},
{ DBGBUS_DSPP, 83, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 92, 1},
{ DBGBUS_DSPP, 92, 2},
{ DBGBUS_DSPP, 92, 3},
{ DBGBUS_DSPP, 92, 4},
{ DBGBUS_DSPP, 92, 5},
{ DBGBUS_DSPP, 92, 6},
{ DBGBUS_DSPP, 92, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 93, 1},
{ DBGBUS_DSPP, 93, 2},
{ DBGBUS_DSPP, 93, 3},
{ DBGBUS_DSPP, 93, 4},
{ DBGBUS_DSPP, 93, 5},
{ DBGBUS_DSPP, 93, 6},
{ DBGBUS_DSPP, 93, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 94, 1},
{ DBGBUS_DSPP, 94, 2},
{ DBGBUS_DSPP, 94, 3},
{ DBGBUS_DSPP, 94, 4},
{ DBGBUS_DSPP, 94, 5},
{ DBGBUS_DSPP, 94, 6},
{ DBGBUS_DSPP, 94, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 95, 1},
{ DBGBUS_DSPP, 95, 2},
{ DBGBUS_DSPP, 95, 3},
{ DBGBUS_DSPP, 95, 4},
{ DBGBUS_DSPP, 95, 5},
{ DBGBUS_DSPP, 95, 6},
{ DBGBUS_DSPP, 95, 7, _sde_debug_bus_lm_dump },
/* LM3 */
{ DBGBUS_DSPP, 110, 1},
{ DBGBUS_DSPP, 110, 2},
{ DBGBUS_DSPP, 110, 3},
{ DBGBUS_DSPP, 110, 4},
{ DBGBUS_DSPP, 110, 5},
{ DBGBUS_DSPP, 110, 6},
{ DBGBUS_DSPP, 110, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 111, 1},
{ DBGBUS_DSPP, 111, 2},
{ DBGBUS_DSPP, 111, 3},
{ DBGBUS_DSPP, 111, 4},
{ DBGBUS_DSPP, 111, 5},
{ DBGBUS_DSPP, 111, 6},
{ DBGBUS_DSPP, 111, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 112, 1},
{ DBGBUS_DSPP, 112, 2},
{ DBGBUS_DSPP, 112, 3},
{ DBGBUS_DSPP, 112, 4},
{ DBGBUS_DSPP, 112, 5},
{ DBGBUS_DSPP, 112, 6},
{ DBGBUS_DSPP, 112, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 113, 1},
{ DBGBUS_DSPP, 113, 2},
{ DBGBUS_DSPP, 113, 3},
{ DBGBUS_DSPP, 113, 4},
{ DBGBUS_DSPP, 113, 5},
{ DBGBUS_DSPP, 113, 6},
{ DBGBUS_DSPP, 113, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 114, 1},
{ DBGBUS_DSPP, 114, 2},
{ DBGBUS_DSPP, 114, 3},
{ DBGBUS_DSPP, 114, 4},
{ DBGBUS_DSPP, 114, 5},
{ DBGBUS_DSPP, 114, 6},
{ DBGBUS_DSPP, 114, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 115, 1},
{ DBGBUS_DSPP, 115, 2},
{ DBGBUS_DSPP, 115, 3},
{ DBGBUS_DSPP, 115, 4},
{ DBGBUS_DSPP, 115, 5},
{ DBGBUS_DSPP, 115, 6},
{ DBGBUS_DSPP, 115, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 116, 1},
{ DBGBUS_DSPP, 116, 2},
{ DBGBUS_DSPP, 116, 3},
{ DBGBUS_DSPP, 116, 4},
{ DBGBUS_DSPP, 116, 5},
{ DBGBUS_DSPP, 116, 6},
{ DBGBUS_DSPP, 116, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 117, 1},
{ DBGBUS_DSPP, 117, 2},
{ DBGBUS_DSPP, 117, 3},
{ DBGBUS_DSPP, 117, 4},
{ DBGBUS_DSPP, 117, 5},
{ DBGBUS_DSPP, 117, 6},
{ DBGBUS_DSPP, 117, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 118, 1},
{ DBGBUS_DSPP, 118, 2},
{ DBGBUS_DSPP, 118, 3},
{ DBGBUS_DSPP, 118, 4},
{ DBGBUS_DSPP, 118, 5},
{ DBGBUS_DSPP, 118, 6},
{ DBGBUS_DSPP, 118, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 119, 1},
{ DBGBUS_DSPP, 119, 2},
{ DBGBUS_DSPP, 119, 3},
{ DBGBUS_DSPP, 119, 4},
{ DBGBUS_DSPP, 119, 5},
{ DBGBUS_DSPP, 119, 6},
{ DBGBUS_DSPP, 119, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 120, 1},
{ DBGBUS_DSPP, 120, 2},
{ DBGBUS_DSPP, 120, 3},
{ DBGBUS_DSPP, 120, 4},
{ DBGBUS_DSPP, 120, 5},
{ DBGBUS_DSPP, 120, 6},
{ DBGBUS_DSPP, 120, 7, _sde_debug_bus_lm_dump },
/* LM4 */
{ DBGBUS_DSPP, 96, 1},
{ DBGBUS_DSPP, 96, 2},
{ DBGBUS_DSPP, 96, 3},
{ DBGBUS_DSPP, 96, 4},
{ DBGBUS_DSPP, 96, 5},
{ DBGBUS_DSPP, 96, 6},
{ DBGBUS_DSPP, 96, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 97, 1},
{ DBGBUS_DSPP, 97, 2},
{ DBGBUS_DSPP, 97, 3},
{ DBGBUS_DSPP, 97, 4},
{ DBGBUS_DSPP, 97, 5},
{ DBGBUS_DSPP, 97, 6},
{ DBGBUS_DSPP, 97, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 98, 1},
{ DBGBUS_DSPP, 98, 2},
{ DBGBUS_DSPP, 98, 3},
{ DBGBUS_DSPP, 98, 4},
{ DBGBUS_DSPP, 98, 5},
{ DBGBUS_DSPP, 98, 6},
{ DBGBUS_DSPP, 98, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 99, 1},
{ DBGBUS_DSPP, 99, 2},
{ DBGBUS_DSPP, 99, 3},
{ DBGBUS_DSPP, 99, 4},
{ DBGBUS_DSPP, 99, 5},
{ DBGBUS_DSPP, 99, 6},
{ DBGBUS_DSPP, 99, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 100, 1},
{ DBGBUS_DSPP, 100, 2},
{ DBGBUS_DSPP, 100, 3},
{ DBGBUS_DSPP, 100, 4},
{ DBGBUS_DSPP, 100, 5},
{ DBGBUS_DSPP, 100, 6},
{ DBGBUS_DSPP, 100, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 101, 1},
{ DBGBUS_DSPP, 101, 2},
{ DBGBUS_DSPP, 101, 3},
{ DBGBUS_DSPP, 101, 4},
{ DBGBUS_DSPP, 101, 5},
{ DBGBUS_DSPP, 101, 6},
{ DBGBUS_DSPP, 101, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 103, 1},
{ DBGBUS_DSPP, 103, 2},
{ DBGBUS_DSPP, 103, 3},
{ DBGBUS_DSPP, 103, 4},
{ DBGBUS_DSPP, 103, 5},
{ DBGBUS_DSPP, 103, 6},
{ DBGBUS_DSPP, 103, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 105, 1},
{ DBGBUS_DSPP, 105, 2},
{ DBGBUS_DSPP, 105, 3},
{ DBGBUS_DSPP, 105, 4},
{ DBGBUS_DSPP, 105, 5},
{ DBGBUS_DSPP, 105, 6},
{ DBGBUS_DSPP, 105, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 106, 1},
{ DBGBUS_DSPP, 106, 2},
{ DBGBUS_DSPP, 106, 3},
{ DBGBUS_DSPP, 106, 4},
{ DBGBUS_DSPP, 106, 5},
{ DBGBUS_DSPP, 106, 6},
{ DBGBUS_DSPP, 106, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 109, 1},
{ DBGBUS_DSPP, 109, 2},
{ DBGBUS_DSPP, 109, 3},
{ DBGBUS_DSPP, 109, 4},
{ DBGBUS_DSPP, 109, 5},
{ DBGBUS_DSPP, 109, 6},
{ DBGBUS_DSPP, 109, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 122, 1},
{ DBGBUS_DSPP, 122, 2},
{ DBGBUS_DSPP, 122, 3},
{ DBGBUS_DSPP, 122, 4},
{ DBGBUS_DSPP, 122, 5},
{ DBGBUS_DSPP, 122, 6},
{ DBGBUS_DSPP, 122, 7, _sde_debug_bus_lm_dump },
/* LM5 */
{ DBGBUS_DSPP, 124, 1},
{ DBGBUS_DSPP, 124, 2},
{ DBGBUS_DSPP, 124, 3},
{ DBGBUS_DSPP, 124, 4},
{ DBGBUS_DSPP, 124, 5},
{ DBGBUS_DSPP, 124, 6},
{ DBGBUS_DSPP, 124, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 125, 1},
{ DBGBUS_DSPP, 125, 2},
{ DBGBUS_DSPP, 125, 3},
{ DBGBUS_DSPP, 125, 4},
{ DBGBUS_DSPP, 125, 5},
{ DBGBUS_DSPP, 125, 6},
{ DBGBUS_DSPP, 125, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 126, 1},
{ DBGBUS_DSPP, 126, 2},
{ DBGBUS_DSPP, 126, 3},
{ DBGBUS_DSPP, 126, 4},
{ DBGBUS_DSPP, 126, 5},
{ DBGBUS_DSPP, 126, 6},
{ DBGBUS_DSPP, 126, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 127, 1},
{ DBGBUS_DSPP, 127, 2},
{ DBGBUS_DSPP, 127, 3},
{ DBGBUS_DSPP, 127, 4},
{ DBGBUS_DSPP, 127, 5},
{ DBGBUS_DSPP, 127, 6},
{ DBGBUS_DSPP, 127, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 128, 1},
{ DBGBUS_DSPP, 128, 2},
{ DBGBUS_DSPP, 128, 3},
{ DBGBUS_DSPP, 128, 4},
{ DBGBUS_DSPP, 128, 5},
{ DBGBUS_DSPP, 128, 6},
{ DBGBUS_DSPP, 128, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 129, 1},
{ DBGBUS_DSPP, 129, 2},
{ DBGBUS_DSPP, 129, 3},
{ DBGBUS_DSPP, 129, 4},
{ DBGBUS_DSPP, 129, 5},
{ DBGBUS_DSPP, 129, 6},
{ DBGBUS_DSPP, 129, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 131, 1},
{ DBGBUS_DSPP, 131, 2},
{ DBGBUS_DSPP, 131, 3},
{ DBGBUS_DSPP, 131, 4},
{ DBGBUS_DSPP, 131, 5},
{ DBGBUS_DSPP, 131, 6},
{ DBGBUS_DSPP, 131, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 132, 1},
{ DBGBUS_DSPP, 132, 2},
{ DBGBUS_DSPP, 132, 3},
{ DBGBUS_DSPP, 132, 4},
{ DBGBUS_DSPP, 132, 5},
{ DBGBUS_DSPP, 132, 6},
{ DBGBUS_DSPP, 132, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 133, 1},
{ DBGBUS_DSPP, 133, 2},
{ DBGBUS_DSPP, 133, 3},
{ DBGBUS_DSPP, 133, 4},
{ DBGBUS_DSPP, 133, 5},
{ DBGBUS_DSPP, 133, 6},
{ DBGBUS_DSPP, 133, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 134, 1},
{ DBGBUS_DSPP, 134, 2},
{ DBGBUS_DSPP, 134, 3},
{ DBGBUS_DSPP, 134, 4},
{ DBGBUS_DSPP, 134, 5},
{ DBGBUS_DSPP, 134, 6},
{ DBGBUS_DSPP, 134, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 135, 1},
{ DBGBUS_DSPP, 135, 2},
{ DBGBUS_DSPP, 135, 3},
{ DBGBUS_DSPP, 135, 4},
{ DBGBUS_DSPP, 135, 5},
{ DBGBUS_DSPP, 135, 6},
{ DBGBUS_DSPP, 135, 7, _sde_debug_bus_lm_dump },
/* csc */
{ DBGBUS_SSPP0, 7, 0},
{ DBGBUS_SSPP0, 7, 1},
{ DBGBUS_SSPP0, 7, 2},
{ DBGBUS_SSPP0, 27, 0},
{ DBGBUS_SSPP0, 27, 1},
{ DBGBUS_SSPP0, 27, 2},
{ DBGBUS_SSPP1, 7, 0},
{ DBGBUS_SSPP1, 7, 1},
{ DBGBUS_SSPP1, 7, 2},
{ DBGBUS_SSPP1, 27, 0},
{ DBGBUS_SSPP1, 27, 1},
{ DBGBUS_SSPP1, 27, 2},
/* pcc */
{ DBGBUS_SSPP0, 43, 3},
{ DBGBUS_SSPP0, 47, 3},
{ DBGBUS_SSPP1, 43, 3},
{ DBGBUS_SSPP1, 47, 3},
/* spa */
{ DBGBUS_SSPP0, 8, 0},
{ DBGBUS_SSPP0, 28, 0},
{ DBGBUS_SSPP1, 8, 0},
{ DBGBUS_SSPP1, 28, 0},
/* dspp pa */
{ DBGBUS_DSPP, 13, 0},
{ DBGBUS_DSPP, 19, 0},
{ DBGBUS_DSPP, 24, 0},
{ DBGBUS_DSPP, 37, 0},
/* igc */
{ DBGBUS_SSPP0, 39, 0},
{ DBGBUS_SSPP0, 39, 1},
{ DBGBUS_SSPP0, 39, 2},
{ DBGBUS_SSPP1, 39, 0},
{ DBGBUS_SSPP1, 39, 1},
{ DBGBUS_SSPP1, 39, 2},
{ DBGBUS_SSPP0, 46, 0},
{ DBGBUS_SSPP0, 46, 1},
{ DBGBUS_SSPP0, 46, 2},
{ DBGBUS_SSPP1, 46, 0},
{ DBGBUS_SSPP1, 46, 1},
{ DBGBUS_SSPP1, 46, 2},
{ DBGBUS_DSPP, 14, 0},
{ DBGBUS_DSPP, 14, 1},
{ DBGBUS_DSPP, 14, 2},
{ DBGBUS_DSPP, 20, 0},
{ DBGBUS_DSPP, 20, 1},
{ DBGBUS_DSPP, 20, 2},
{ DBGBUS_DSPP, 25, 0},
{ DBGBUS_DSPP, 25, 1},
{ DBGBUS_DSPP, 25, 2},
{ DBGBUS_DSPP, 38, 0},
{ DBGBUS_DSPP, 38, 1},
{ DBGBUS_DSPP, 38, 2},
/* intf0-3 */
{ DBGBUS_PERIPH, 0, 0},
{ DBGBUS_PERIPH, 1, 0},
{ DBGBUS_PERIPH, 2, 0},
{ DBGBUS_PERIPH, 3, 0},
{ DBGBUS_PERIPH, 4, 0},
{ DBGBUS_PERIPH, 5, 0},
/* te counter wrapper */
{ DBGBUS_PERIPH, 60, 0},
{ DBGBUS_PERIPH, 60, 1},
{ DBGBUS_PERIPH, 60, 2},
{ DBGBUS_PERIPH, 60, 3},
{ DBGBUS_PERIPH, 60, 4},
{ DBGBUS_PERIPH, 60, 5},
/* dsc0 */
{ DBGBUS_PERIPH, 47, 0},
{ DBGBUS_PERIPH, 47, 1},
{ DBGBUS_PERIPH, 47, 2},
{ DBGBUS_PERIPH, 47, 3},
{ DBGBUS_PERIPH, 47, 4},
{ DBGBUS_PERIPH, 47, 5},
{ DBGBUS_PERIPH, 47, 6},
{ DBGBUS_PERIPH, 47, 7},
/* dsc1 */
{ DBGBUS_PERIPH, 48, 0},
{ DBGBUS_PERIPH, 48, 1},
{ DBGBUS_PERIPH, 48, 2},
{ DBGBUS_PERIPH, 48, 3},
{ DBGBUS_PERIPH, 48, 4},
{ DBGBUS_PERIPH, 48, 5},
{ DBGBUS_PERIPH, 48, 6},
{ DBGBUS_PERIPH, 48, 7},
/* dsc2 */
{ DBGBUS_PERIPH, 50, 0},
{ DBGBUS_PERIPH, 50, 1},
{ DBGBUS_PERIPH, 50, 2},
{ DBGBUS_PERIPH, 50, 3},
{ DBGBUS_PERIPH, 50, 4},
{ DBGBUS_PERIPH, 50, 5},
{ DBGBUS_PERIPH, 50, 6},
{ DBGBUS_PERIPH, 50, 7},
/* dsc3 */
{ DBGBUS_PERIPH, 51, 0},
{ DBGBUS_PERIPH, 51, 1},
{ DBGBUS_PERIPH, 51, 2},
{ DBGBUS_PERIPH, 51, 3},
{ DBGBUS_PERIPH, 51, 4},
{ DBGBUS_PERIPH, 51, 5},
{ DBGBUS_PERIPH, 51, 6},
{ DBGBUS_PERIPH, 51, 7},
/* dsc4 */
{ DBGBUS_PERIPH, 52, 0},
{ DBGBUS_PERIPH, 52, 1},
{ DBGBUS_PERIPH, 52, 2},
{ DBGBUS_PERIPH, 52, 3},
{ DBGBUS_PERIPH, 52, 4},
{ DBGBUS_PERIPH, 52, 5},
{ DBGBUS_PERIPH, 52, 6},
{ DBGBUS_PERIPH, 52, 7},
/* dsc5 */
{ DBGBUS_PERIPH, 53, 0},
{ DBGBUS_PERIPH, 53, 1},
{ DBGBUS_PERIPH, 53, 2},
{ DBGBUS_PERIPH, 53, 3},
{ DBGBUS_PERIPH, 53, 4},
{ DBGBUS_PERIPH, 53, 5},
{ DBGBUS_PERIPH, 53, 6},
{ DBGBUS_PERIPH, 53, 7},
/* tear-check */
/* INTF_0 */
{ DBGBUS_PERIPH, 63, 0 },
{ DBGBUS_PERIPH, 63, 1 },
{ DBGBUS_PERIPH, 63, 2 },
{ DBGBUS_PERIPH, 63, 3 },
{ DBGBUS_PERIPH, 63, 4 },
{ DBGBUS_PERIPH, 63, 5 },
{ DBGBUS_PERIPH, 63, 6 },
{ DBGBUS_PERIPH, 63, 7 },
/* INTF_1 */
{ DBGBUS_PERIPH, 64, 0 },
{ DBGBUS_PERIPH, 64, 1 },
{ DBGBUS_PERIPH, 64, 2 },
{ DBGBUS_PERIPH, 64, 3 },
{ DBGBUS_PERIPH, 64, 4 },
{ DBGBUS_PERIPH, 64, 5 },
{ DBGBUS_PERIPH, 64, 6 },
{ DBGBUS_PERIPH, 64, 7 },
/* INTF_2 */
{ DBGBUS_PERIPH, 65, 0 },
{ DBGBUS_PERIPH, 65, 1 },
{ DBGBUS_PERIPH, 65, 2 },
{ DBGBUS_PERIPH, 65, 3 },
{ DBGBUS_PERIPH, 65, 4 },
{ DBGBUS_PERIPH, 65, 5 },
{ DBGBUS_PERIPH, 65, 6 },
{ DBGBUS_PERIPH, 65, 7 },
/* INTF_4 */
{ DBGBUS_PERIPH, 66, 0 },
{ DBGBUS_PERIPH, 66, 1 },
{ DBGBUS_PERIPH, 66, 2 },
{ DBGBUS_PERIPH, 66, 3 },
{ DBGBUS_PERIPH, 66, 4 },
{ DBGBUS_PERIPH, 66, 5 },
{ DBGBUS_PERIPH, 66, 6 },
{ DBGBUS_PERIPH, 66, 7 },
/* INTF_5 */
{ DBGBUS_PERIPH, 67, 0 },
{ DBGBUS_PERIPH, 67, 1 },
{ DBGBUS_PERIPH, 67, 2 },
{ DBGBUS_PERIPH, 67, 3 },
{ DBGBUS_PERIPH, 67, 4 },
{ DBGBUS_PERIPH, 67, 5 },
{ DBGBUS_PERIPH, 67, 6 },
{ DBGBUS_PERIPH, 67, 7 },
/* INTF_3 */
{ DBGBUS_PERIPH, 73, 0 },
{ DBGBUS_PERIPH, 73, 1 },
{ DBGBUS_PERIPH, 73, 2 },
{ DBGBUS_PERIPH, 73, 3 },
{ DBGBUS_PERIPH, 73, 4 },
{ DBGBUS_PERIPH, 73, 5 },
{ DBGBUS_PERIPH, 73, 6 },
{ DBGBUS_PERIPH, 73, 7 },
/* cdwn */
{ DBGBUS_PERIPH, 80, 0},
{ DBGBUS_PERIPH, 80, 1},
{ DBGBUS_PERIPH, 80, 2},
{ DBGBUS_PERIPH, 81, 0},
{ DBGBUS_PERIPH, 81, 1},
{ DBGBUS_PERIPH, 81, 2},
{ DBGBUS_PERIPH, 82, 0},
{ DBGBUS_PERIPH, 82, 1},
{ DBGBUS_PERIPH, 82, 2},
{ DBGBUS_PERIPH, 82, 3},
{ DBGBUS_PERIPH, 82, 4},
{ DBGBUS_PERIPH, 82, 5},
{ DBGBUS_PERIPH, 82, 6},
{ DBGBUS_PERIPH, 82, 7},
/* DPTX1 */
{ DBGBUS_PERIPH, 68, 0},
{ DBGBUS_PERIPH, 68, 1},
{ DBGBUS_PERIPH, 68, 2},
{ DBGBUS_PERIPH, 68, 3},
{ DBGBUS_PERIPH, 68, 4},
{ DBGBUS_PERIPH, 68, 5},
{ DBGBUS_PERIPH, 68, 6},
{ DBGBUS_PERIPH, 68, 7},
/* DP */
{ DBGBUS_PERIPH, 69, 0},
{ DBGBUS_PERIPH, 69, 1},
{ DBGBUS_PERIPH, 69, 2},
{ DBGBUS_PERIPH, 69, 3},
{ DBGBUS_PERIPH, 69, 4},
{ DBGBUS_PERIPH, 69, 5},
/* dsi0 */
{ DBGBUS_PERIPH, 70, 0},
{ DBGBUS_PERIPH, 70, 1},
{ DBGBUS_PERIPH, 70, 2},
{ DBGBUS_PERIPH, 70, 3},
{ DBGBUS_PERIPH, 70, 4},
{ DBGBUS_PERIPH, 70, 5},
/* dsi1 */
{ DBGBUS_PERIPH, 71, 0},
{ DBGBUS_PERIPH, 71, 1},
{ DBGBUS_PERIPH, 71, 2},
{ DBGBUS_PERIPH, 71, 3},
{ DBGBUS_PERIPH, 71, 4},
{ DBGBUS_PERIPH, 71, 5},
/* eDP */
{ DBGBUS_PERIPH, 72, 0},
{ DBGBUS_PERIPH, 72, 1},
{ DBGBUS_PERIPH, 72, 2},
{ DBGBUS_PERIPH, 72, 3},
{ DBGBUS_PERIPH, 72, 4},
{ DBGBUS_PERIPH, 72, 5},
};
static struct sde_debug_bus_entry dbg_bus_sde_kona[] = {
/* Unpack 0 sspp 0*/
{ DBGBUS_SSPP0, 35, 2 },
{ DBGBUS_SSPP0, 50, 2 },
{ DBGBUS_SSPP0, 60, 2 },
{ DBGBUS_SSPP0, 70, 2 },
/* Unpack 1 sspp 0*/
{ DBGBUS_SSPP0, 36, 2 },
{ DBGBUS_SSPP0, 51, 2 },
{ DBGBUS_SSPP0, 61, 2 },
{ DBGBUS_SSPP0, 71, 2 },
/* Unpack 2 sspp 0*/
{ DBGBUS_SSPP0, 37, 2 },
{ DBGBUS_SSPP0, 52, 2 },
{ DBGBUS_SSPP0, 62, 2 },
{ DBGBUS_SSPP0, 72, 2 },
/* Unpack 3 sspp 0*/
{ DBGBUS_SSPP0, 38, 2 },
{ DBGBUS_SSPP0, 53, 2 },
{ DBGBUS_SSPP0, 63, 2 },
{ DBGBUS_SSPP0, 73, 2 },
/* Unpack 0 sspp 1*/
{ DBGBUS_SSPP1, 35, 2 },
{ DBGBUS_SSPP1, 50, 2 },
{ DBGBUS_SSPP1, 60, 2 },
{ DBGBUS_SSPP1, 70, 2 },
/* Unpack 1 sspp 1*/
{ DBGBUS_SSPP1, 36, 2 },
{ DBGBUS_SSPP1, 51, 2 },
{ DBGBUS_SSPP1, 61, 2 },
{ DBGBUS_SSPP1, 71, 2 },
/* Unpack 2 sspp 1*/
{ DBGBUS_SSPP1, 37, 2 },
{ DBGBUS_SSPP1, 52, 2 },
{ DBGBUS_SSPP1, 62, 2 },
{ DBGBUS_SSPP1, 72, 2 },
/* Unpack 3 sspp 1*/
{ DBGBUS_SSPP1, 38, 2 },
{ DBGBUS_SSPP1, 53, 2 },
{ DBGBUS_SSPP1, 63, 2 },
{ DBGBUS_SSPP1, 73, 2 },
/* scheduler */
{ DBGBUS_DSPP, 130, 0 },
{ DBGBUS_DSPP, 130, 1 },
{ DBGBUS_DSPP, 130, 2 },
{ DBGBUS_DSPP, 130, 3 },
{ DBGBUS_DSPP, 130, 4 },
{ DBGBUS_DSPP, 130, 5 },
/* fetch sspp0 */
/* vig 0 */
{ DBGBUS_SSPP0, 0, 0 },
{ DBGBUS_SSPP0, 0, 1 },
{ DBGBUS_SSPP0, 0, 2 },
{ DBGBUS_SSPP0, 0, 3 },
{ DBGBUS_SSPP0, 0, 4 },
{ DBGBUS_SSPP0, 0, 5 },
{ DBGBUS_SSPP0, 0, 6 },
{ DBGBUS_SSPP0, 0, 7 },
{ DBGBUS_SSPP0, 1, 0 },
{ DBGBUS_SSPP0, 1, 1 },
{ DBGBUS_SSPP0, 1, 2 },
{ DBGBUS_SSPP0, 1, 3 },
{ DBGBUS_SSPP0, 1, 4 },
{ DBGBUS_SSPP0, 1, 5 },
{ DBGBUS_SSPP0, 1, 6 },
{ DBGBUS_SSPP0, 1, 7 },
{ DBGBUS_SSPP0, 2, 0 },
{ DBGBUS_SSPP0, 2, 1 },
{ DBGBUS_SSPP0, 2, 2 },
{ DBGBUS_SSPP0, 2, 3 },
{ DBGBUS_SSPP0, 2, 4 },
{ DBGBUS_SSPP0, 2, 5 },
{ DBGBUS_SSPP0, 2, 6 },
{ DBGBUS_SSPP0, 2, 7 },
{ DBGBUS_SSPP0, 4, 0 },
{ DBGBUS_SSPP0, 4, 1 },
{ DBGBUS_SSPP0, 4, 2 },
{ DBGBUS_SSPP0, 4, 3 },
{ DBGBUS_SSPP0, 4, 4 },
{ DBGBUS_SSPP0, 4, 5 },
{ DBGBUS_SSPP0, 4, 6 },
{ DBGBUS_SSPP0, 4, 7 },
{ DBGBUS_SSPP0, 5, 0 },
{ DBGBUS_SSPP0, 5, 1 },
{ DBGBUS_SSPP0, 5, 2 },
{ DBGBUS_SSPP0, 5, 3 },
{ DBGBUS_SSPP0, 5, 4 },
{ DBGBUS_SSPP0, 5, 5 },
{ DBGBUS_SSPP0, 5, 6 },
{ DBGBUS_SSPP0, 5, 7 },
/* vig 2 */
{ DBGBUS_SSPP0, 20, 0 },
{ DBGBUS_SSPP0, 20, 1 },
{ DBGBUS_SSPP0, 20, 2 },
{ DBGBUS_SSPP0, 20, 3 },
{ DBGBUS_SSPP0, 20, 4 },
{ DBGBUS_SSPP0, 20, 5 },
{ DBGBUS_SSPP0, 20, 6 },
{ DBGBUS_SSPP0, 20, 7 },
{ DBGBUS_SSPP0, 21, 0 },
{ DBGBUS_SSPP0, 21, 1 },
{ DBGBUS_SSPP0, 21, 2 },
{ DBGBUS_SSPP0, 21, 3 },
{ DBGBUS_SSPP0, 21, 4 },
{ DBGBUS_SSPP0, 21, 5 },
{ DBGBUS_SSPP0, 21, 6 },
{ DBGBUS_SSPP0, 21, 7 },
{ DBGBUS_SSPP0, 22, 0 },
{ DBGBUS_SSPP0, 22, 1 },
{ DBGBUS_SSPP0, 22, 2 },
{ DBGBUS_SSPP0, 22, 3 },
{ DBGBUS_SSPP0, 22, 4 },
{ DBGBUS_SSPP0, 22, 5 },
{ DBGBUS_SSPP0, 22, 6 },
{ DBGBUS_SSPP0, 22, 7 },
{ DBGBUS_SSPP0, 24, 0 },
{ DBGBUS_SSPP0, 24, 1 },
{ DBGBUS_SSPP0, 24, 2 },
{ DBGBUS_SSPP0, 24, 3 },
{ DBGBUS_SSPP0, 24, 4 },
{ DBGBUS_SSPP0, 24, 5 },
{ DBGBUS_SSPP0, 24, 6 },
{ DBGBUS_SSPP0, 24, 7 },
{ DBGBUS_SSPP0, 25, 0 },
{ DBGBUS_SSPP0, 25, 1 },
{ DBGBUS_SSPP0, 25, 2 },
{ DBGBUS_SSPP0, 25, 3 },
{ DBGBUS_SSPP0, 25, 4 },
{ DBGBUS_SSPP0, 25, 5 },
{ DBGBUS_SSPP0, 25, 6 },
{ DBGBUS_SSPP0, 25, 7 },
/* dma 2 */
{ DBGBUS_SSPP0, 30, 0 },
{ DBGBUS_SSPP0, 30, 1 },
{ DBGBUS_SSPP0, 30, 2 },
{ DBGBUS_SSPP0, 30, 3 },
{ DBGBUS_SSPP0, 30, 4 },
{ DBGBUS_SSPP0, 30, 5 },
{ DBGBUS_SSPP0, 30, 6 },
{ DBGBUS_SSPP0, 30, 7 },
{ DBGBUS_SSPP0, 31, 0 },
{ DBGBUS_SSPP0, 31, 1 },
{ DBGBUS_SSPP0, 31, 2 },
{ DBGBUS_SSPP0, 31, 3 },
{ DBGBUS_SSPP0, 31, 4 },
{ DBGBUS_SSPP0, 31, 5 },
{ DBGBUS_SSPP0, 31, 6 },
{ DBGBUS_SSPP0, 31, 7 },
{ DBGBUS_SSPP0, 32, 0 },
{ DBGBUS_SSPP0, 32, 1 },
{ DBGBUS_SSPP0, 32, 2 },
{ DBGBUS_SSPP0, 32, 3 },
{ DBGBUS_SSPP0, 32, 4 },
{ DBGBUS_SSPP0, 32, 5 },
{ DBGBUS_SSPP0, 32, 6 },
{ DBGBUS_SSPP0, 32, 7 },
{ DBGBUS_SSPP0, 33, 0 },
{ DBGBUS_SSPP0, 33, 1 },
{ DBGBUS_SSPP0, 33, 2 },
{ DBGBUS_SSPP0, 33, 3 },
{ DBGBUS_SSPP0, 33, 4 },
{ DBGBUS_SSPP0, 33, 5 },
{ DBGBUS_SSPP0, 33, 6 },
{ DBGBUS_SSPP0, 33, 7 },
{ DBGBUS_SSPP0, 34, 0 },
{ DBGBUS_SSPP0, 34, 1 },
{ DBGBUS_SSPP0, 34, 2 },
{ DBGBUS_SSPP0, 34, 3 },
{ DBGBUS_SSPP0, 34, 4 },
{ DBGBUS_SSPP0, 34, 5 },
{ DBGBUS_SSPP0, 34, 6 },
{ DBGBUS_SSPP0, 34, 7 },
/* dma 0 */
{ DBGBUS_SSPP0, 40, 0 },
{ DBGBUS_SSPP0, 40, 1 },
{ DBGBUS_SSPP0, 40, 2 },
{ DBGBUS_SSPP0, 40, 3 },
{ DBGBUS_SSPP0, 40, 4 },
{ DBGBUS_SSPP0, 40, 5 },
{ DBGBUS_SSPP0, 40, 6 },
{ DBGBUS_SSPP0, 40, 7 },
{ DBGBUS_SSPP0, 41, 0 },
{ DBGBUS_SSPP0, 41, 1 },
{ DBGBUS_SSPP0, 41, 2 },
{ DBGBUS_SSPP0, 41, 3 },
{ DBGBUS_SSPP0, 41, 4 },
{ DBGBUS_SSPP0, 41, 5 },
{ DBGBUS_SSPP0, 41, 6 },
{ DBGBUS_SSPP0, 41, 7 },
{ DBGBUS_SSPP0, 42, 0 },
{ DBGBUS_SSPP0, 42, 1 },
{ DBGBUS_SSPP0, 42, 2 },
{ DBGBUS_SSPP0, 42, 3 },
{ DBGBUS_SSPP0, 42, 4 },
{ DBGBUS_SSPP0, 42, 5 },
{ DBGBUS_SSPP0, 42, 6 },
{ DBGBUS_SSPP0, 42, 7 },
{ DBGBUS_SSPP0, 44, 0 },
{ DBGBUS_SSPP0, 44, 1 },
{ DBGBUS_SSPP0, 44, 2 },
{ DBGBUS_SSPP0, 44, 3 },
{ DBGBUS_SSPP0, 44, 4 },
{ DBGBUS_SSPP0, 44, 5 },
{ DBGBUS_SSPP0, 44, 6 },
{ DBGBUS_SSPP0, 44, 7 },
{ DBGBUS_SSPP0, 45, 0 },
{ DBGBUS_SSPP0, 45, 1 },
{ DBGBUS_SSPP0, 45, 2 },
{ DBGBUS_SSPP0, 45, 3 },
{ DBGBUS_SSPP0, 45, 4 },
{ DBGBUS_SSPP0, 45, 5 },
{ DBGBUS_SSPP0, 45, 6 },
{ DBGBUS_SSPP0, 45, 7 },
/* fetch sspp1 */
/* vig 1 */
{ DBGBUS_SSPP1, 0, 0 },
{ DBGBUS_SSPP1, 0, 1 },
{ DBGBUS_SSPP1, 0, 2 },
{ DBGBUS_SSPP1, 0, 3 },
{ DBGBUS_SSPP1, 0, 4 },
{ DBGBUS_SSPP1, 0, 5 },
{ DBGBUS_SSPP1, 0, 6 },
{ DBGBUS_SSPP1, 0, 7 },
{ DBGBUS_SSPP1, 1, 0 },
{ DBGBUS_SSPP1, 1, 1 },
{ DBGBUS_SSPP1, 1, 2 },
{ DBGBUS_SSPP1, 1, 3 },
{ DBGBUS_SSPP1, 1, 4 },
{ DBGBUS_SSPP1, 1, 5 },
{ DBGBUS_SSPP1, 1, 6 },
{ DBGBUS_SSPP1, 1, 7 },
{ DBGBUS_SSPP1, 2, 0 },
{ DBGBUS_SSPP1, 2, 1 },
{ DBGBUS_SSPP1, 2, 2 },
{ DBGBUS_SSPP1, 2, 3 },
{ DBGBUS_SSPP1, 2, 4 },
{ DBGBUS_SSPP1, 2, 5 },
{ DBGBUS_SSPP1, 2, 6 },
{ DBGBUS_SSPP1, 2, 7 },
{ DBGBUS_SSPP1, 4, 0 },
{ DBGBUS_SSPP1, 4, 1 },
{ DBGBUS_SSPP1, 4, 2 },
{ DBGBUS_SSPP1, 4, 3 },
{ DBGBUS_SSPP1, 4, 4 },
{ DBGBUS_SSPP1, 4, 5 },
{ DBGBUS_SSPP1, 4, 6 },
{ DBGBUS_SSPP1, 4, 7 },
{ DBGBUS_SSPP1, 5, 0 },
{ DBGBUS_SSPP1, 5, 1 },
{ DBGBUS_SSPP1, 5, 2 },
{ DBGBUS_SSPP1, 5, 3 },
{ DBGBUS_SSPP1, 5, 4 },
{ DBGBUS_SSPP1, 5, 5 },
{ DBGBUS_SSPP1, 5, 6 },
{ DBGBUS_SSPP1, 5, 7 },
/* vig 3 */
{ DBGBUS_SSPP1, 20, 0 },
{ DBGBUS_SSPP1, 20, 1 },
{ DBGBUS_SSPP1, 20, 2 },
{ DBGBUS_SSPP1, 20, 3 },
{ DBGBUS_SSPP1, 20, 4 },
{ DBGBUS_SSPP1, 20, 5 },
{ DBGBUS_SSPP1, 20, 6 },
{ DBGBUS_SSPP1, 20, 7 },
{ DBGBUS_SSPP1, 21, 0 },
{ DBGBUS_SSPP1, 21, 1 },
{ DBGBUS_SSPP1, 21, 2 },
{ DBGBUS_SSPP1, 21, 3 },
{ DBGBUS_SSPP1, 21, 4 },
{ DBGBUS_SSPP1, 21, 5 },
{ DBGBUS_SSPP1, 21, 6 },
{ DBGBUS_SSPP1, 21, 7 },
{ DBGBUS_SSPP1, 22, 0 },
{ DBGBUS_SSPP1, 22, 1 },
{ DBGBUS_SSPP1, 22, 2 },
{ DBGBUS_SSPP1, 22, 3 },
{ DBGBUS_SSPP1, 22, 4 },
{ DBGBUS_SSPP1, 22, 5 },
{ DBGBUS_SSPP1, 22, 6 },
{ DBGBUS_SSPP1, 22, 7 },
{ DBGBUS_SSPP1, 24, 0 },
{ DBGBUS_SSPP1, 24, 1 },
{ DBGBUS_SSPP1, 24, 2 },
{ DBGBUS_SSPP1, 24, 3 },
{ DBGBUS_SSPP1, 24, 4 },
{ DBGBUS_SSPP1, 24, 5 },
{ DBGBUS_SSPP1, 24, 6 },
{ DBGBUS_SSPP1, 24, 7 },
{ DBGBUS_SSPP1, 25, 0 },
{ DBGBUS_SSPP1, 25, 1 },
{ DBGBUS_SSPP1, 25, 2 },
{ DBGBUS_SSPP1, 25, 3 },
{ DBGBUS_SSPP1, 25, 4 },
{ DBGBUS_SSPP1, 25, 5 },
{ DBGBUS_SSPP1, 25, 6 },
{ DBGBUS_SSPP1, 25, 7 },
/* dma 3 */
{ DBGBUS_SSPP1, 30, 0 },
{ DBGBUS_SSPP1, 30, 1 },
{ DBGBUS_SSPP1, 30, 2 },
{ DBGBUS_SSPP1, 30, 3 },
{ DBGBUS_SSPP1, 30, 4 },
{ DBGBUS_SSPP1, 30, 5 },
{ DBGBUS_SSPP1, 30, 6 },
{ DBGBUS_SSPP1, 30, 7 },
{ DBGBUS_SSPP1, 31, 0 },
{ DBGBUS_SSPP1, 31, 1 },
{ DBGBUS_SSPP1, 31, 2 },
{ DBGBUS_SSPP1, 31, 3 },
{ DBGBUS_SSPP1, 31, 4 },
{ DBGBUS_SSPP1, 31, 5 },
{ DBGBUS_SSPP1, 31, 6 },
{ DBGBUS_SSPP1, 31, 7 },
{ DBGBUS_SSPP1, 32, 0 },
{ DBGBUS_SSPP1, 32, 1 },
{ DBGBUS_SSPP1, 32, 2 },
{ DBGBUS_SSPP1, 32, 3 },
{ DBGBUS_SSPP1, 32, 4 },
{ DBGBUS_SSPP1, 32, 5 },
{ DBGBUS_SSPP1, 32, 6 },
{ DBGBUS_SSPP1, 32, 7 },
{ DBGBUS_SSPP1, 33, 0 },
{ DBGBUS_SSPP1, 33, 1 },
{ DBGBUS_SSPP1, 33, 2 },
{ DBGBUS_SSPP1, 33, 3 },
{ DBGBUS_SSPP1, 33, 4 },
{ DBGBUS_SSPP1, 33, 5 },
{ DBGBUS_SSPP1, 33, 6 },
{ DBGBUS_SSPP1, 33, 7 },
{ DBGBUS_SSPP1, 34, 0 },
{ DBGBUS_SSPP1, 34, 1 },
{ DBGBUS_SSPP1, 34, 2 },
{ DBGBUS_SSPP1, 34, 3 },
{ DBGBUS_SSPP1, 34, 4 },
{ DBGBUS_SSPP1, 34, 5 },
{ DBGBUS_SSPP1, 34, 6 },
{ DBGBUS_SSPP1, 34, 7 },
/* dma 1 */
{ DBGBUS_SSPP1, 40, 0 },
{ DBGBUS_SSPP1, 40, 1 },
{ DBGBUS_SSPP1, 40, 2 },
{ DBGBUS_SSPP1, 40, 3 },
{ DBGBUS_SSPP1, 40, 4 },
{ DBGBUS_SSPP1, 40, 5 },
{ DBGBUS_SSPP1, 40, 6 },
{ DBGBUS_SSPP1, 40, 7 },
{ DBGBUS_SSPP1, 41, 0 },
{ DBGBUS_SSPP1, 41, 1 },
{ DBGBUS_SSPP1, 41, 2 },
{ DBGBUS_SSPP1, 41, 3 },
{ DBGBUS_SSPP1, 41, 4 },
{ DBGBUS_SSPP1, 41, 5 },
{ DBGBUS_SSPP1, 41, 6 },
{ DBGBUS_SSPP1, 41, 7 },
{ DBGBUS_SSPP1, 42, 0 },
{ DBGBUS_SSPP1, 42, 1 },
{ DBGBUS_SSPP1, 42, 2 },
{ DBGBUS_SSPP1, 42, 3 },
{ DBGBUS_SSPP1, 42, 4 },
{ DBGBUS_SSPP1, 42, 5 },
{ DBGBUS_SSPP1, 42, 6 },
{ DBGBUS_SSPP1, 42, 7 },
{ DBGBUS_SSPP1, 44, 0 },
{ DBGBUS_SSPP1, 44, 1 },
{ DBGBUS_SSPP1, 44, 2 },
{ DBGBUS_SSPP1, 44, 3 },
{ DBGBUS_SSPP1, 44, 4 },
{ DBGBUS_SSPP1, 44, 5 },
{ DBGBUS_SSPP1, 44, 6 },
{ DBGBUS_SSPP1, 44, 7 },
{ DBGBUS_SSPP1, 45, 0 },
{ DBGBUS_SSPP1, 45, 1 },
{ DBGBUS_SSPP1, 45, 2 },
{ DBGBUS_SSPP1, 45, 3 },
{ DBGBUS_SSPP1, 45, 4 },
{ DBGBUS_SSPP1, 45, 5 },
{ DBGBUS_SSPP1, 45, 6 },
{ DBGBUS_SSPP1, 45, 7 },
/* ppb_0 */
{ DBGBUS_DSPP, 31, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 33, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 35, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 42, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 47, 0, _sde_debug_bus_ppb0_dump },
{ DBGBUS_DSPP, 49, 0, _sde_debug_bus_ppb0_dump },
/* ppb_1 */
{ DBGBUS_DSPP, 32, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 34, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 36, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 43, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 48, 0, _sde_debug_bus_ppb1_dump },
{ DBGBUS_DSPP, 50, 0, _sde_debug_bus_ppb1_dump },
/* crossbar */
{ DBGBUS_DSPP, 0, 0, _sde_debug_bus_xbar_dump },
/* rotator */
{ DBGBUS_DSPP, 9, 0},
/* ltm */
{ DBGBUS_DSPP, 45, 0, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 1, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 2, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 3, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 4, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 5, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 6, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 7, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 8, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 9, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 10, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 11, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 12, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 13, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 14, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 15, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 16, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 17, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 18, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 45, 31, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 0, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 1, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 2, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 3, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 4, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 5, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 6, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 7, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 8, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 9, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 10, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 11, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 12, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 13, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 14, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 15, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 16, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 17, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 18, _sde_debug_bus_ltm_dump},
{ DBGBUS_DSPP, 46, 31, _sde_debug_bus_ltm_dump},
/* blend */
/* LM0 */
{ DBGBUS_DSPP, 63, 1},
{ DBGBUS_DSPP, 63, 2},
{ DBGBUS_DSPP, 63, 3},
{ DBGBUS_DSPP, 63, 4},
{ DBGBUS_DSPP, 63, 5},
{ DBGBUS_DSPP, 63, 6},
{ DBGBUS_DSPP, 63, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 64, 1},
{ DBGBUS_DSPP, 64, 2},
{ DBGBUS_DSPP, 64, 3},
{ DBGBUS_DSPP, 64, 4},
{ DBGBUS_DSPP, 64, 5},
{ DBGBUS_DSPP, 64, 6},
{ DBGBUS_DSPP, 64, 7},
{ DBGBUS_DSPP, 65, 1},
{ DBGBUS_DSPP, 65, 2},
{ DBGBUS_DSPP, 65, 3},
{ DBGBUS_DSPP, 65, 4},
{ DBGBUS_DSPP, 65, 5},
{ DBGBUS_DSPP, 65, 6},
{ DBGBUS_DSPP, 65, 7},
{ DBGBUS_DSPP, 66, 1},
{ DBGBUS_DSPP, 66, 2},
{ DBGBUS_DSPP, 66, 3},
{ DBGBUS_DSPP, 66, 4},
{ DBGBUS_DSPP, 66, 5},
{ DBGBUS_DSPP, 66, 6},
{ DBGBUS_DSPP, 66, 7},
{ DBGBUS_DSPP, 67, 1},
{ DBGBUS_DSPP, 67, 2},
{ DBGBUS_DSPP, 67, 3},
{ DBGBUS_DSPP, 67, 4},
{ DBGBUS_DSPP, 67, 5},
{ DBGBUS_DSPP, 67, 6},
{ DBGBUS_DSPP, 67, 7},
{ DBGBUS_DSPP, 68, 1},
{ DBGBUS_DSPP, 68, 2},
{ DBGBUS_DSPP, 68, 3},
{ DBGBUS_DSPP, 68, 4},
{ DBGBUS_DSPP, 68, 5},
{ DBGBUS_DSPP, 68, 6},
{ DBGBUS_DSPP, 68, 7},
{ DBGBUS_DSPP, 69, 1},
{ DBGBUS_DSPP, 69, 2},
{ DBGBUS_DSPP, 69, 3},
{ DBGBUS_DSPP, 69, 4},
{ DBGBUS_DSPP, 69, 5},
{ DBGBUS_DSPP, 69, 6},
{ DBGBUS_DSPP, 69, 7},
{ DBGBUS_DSPP, 84, 1},
{ DBGBUS_DSPP, 84, 2},
{ DBGBUS_DSPP, 84, 3},
{ DBGBUS_DSPP, 84, 4},
{ DBGBUS_DSPP, 84, 5},
{ DBGBUS_DSPP, 84, 6},
{ DBGBUS_DSPP, 84, 7},
{ DBGBUS_DSPP, 85, 1},
{ DBGBUS_DSPP, 85, 2},
{ DBGBUS_DSPP, 85, 3},
{ DBGBUS_DSPP, 85, 4},
{ DBGBUS_DSPP, 85, 5},
{ DBGBUS_DSPP, 85, 6},
{ DBGBUS_DSPP, 85, 7},
{ DBGBUS_DSPP, 86, 1},
{ DBGBUS_DSPP, 86, 2},
{ DBGBUS_DSPP, 86, 3},
{ DBGBUS_DSPP, 86, 4},
{ DBGBUS_DSPP, 86, 5},
{ DBGBUS_DSPP, 86, 6},
{ DBGBUS_DSPP, 86, 7},
{ DBGBUS_DSPP, 87, 1},
{ DBGBUS_DSPP, 87, 2},
{ DBGBUS_DSPP, 87, 3},
{ DBGBUS_DSPP, 87, 4},
{ DBGBUS_DSPP, 87, 5},
{ DBGBUS_DSPP, 87, 6},
{ DBGBUS_DSPP, 87, 7},
/* LM1 */
{ DBGBUS_DSPP, 70, 1},
{ DBGBUS_DSPP, 70, 2},
{ DBGBUS_DSPP, 70, 3},
{ DBGBUS_DSPP, 70, 4},
{ DBGBUS_DSPP, 70, 5},
{ DBGBUS_DSPP, 70, 6},
{ DBGBUS_DSPP, 70, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 71, 1},
{ DBGBUS_DSPP, 71, 2},
{ DBGBUS_DSPP, 71, 3},
{ DBGBUS_DSPP, 71, 4},
{ DBGBUS_DSPP, 71, 5},
{ DBGBUS_DSPP, 71, 6},
{ DBGBUS_DSPP, 71, 7},
{ DBGBUS_DSPP, 72, 1},
{ DBGBUS_DSPP, 72, 2},
{ DBGBUS_DSPP, 72, 3},
{ DBGBUS_DSPP, 72, 4},
{ DBGBUS_DSPP, 72, 5},
{ DBGBUS_DSPP, 72, 6},
{ DBGBUS_DSPP, 72, 7},
{ DBGBUS_DSPP, 73, 1},
{ DBGBUS_DSPP, 73, 2},
{ DBGBUS_DSPP, 73, 3},
{ DBGBUS_DSPP, 73, 4},
{ DBGBUS_DSPP, 73, 5},
{ DBGBUS_DSPP, 73, 6},
{ DBGBUS_DSPP, 73, 7},
{ DBGBUS_DSPP, 74, 1},
{ DBGBUS_DSPP, 74, 2},
{ DBGBUS_DSPP, 74, 3},
{ DBGBUS_DSPP, 74, 4},
{ DBGBUS_DSPP, 74, 5},
{ DBGBUS_DSPP, 74, 6},
{ DBGBUS_DSPP, 74, 7},
{ DBGBUS_DSPP, 75, 1},
{ DBGBUS_DSPP, 75, 2},
{ DBGBUS_DSPP, 75, 3},
{ DBGBUS_DSPP, 75, 4},
{ DBGBUS_DSPP, 75, 5},
{ DBGBUS_DSPP, 75, 6},
{ DBGBUS_DSPP, 75, 7},
{ DBGBUS_DSPP, 76, 1},
{ DBGBUS_DSPP, 76, 2},
{ DBGBUS_DSPP, 76, 3},
{ DBGBUS_DSPP, 76, 4},
{ DBGBUS_DSPP, 76, 5},
{ DBGBUS_DSPP, 76, 6},
{ DBGBUS_DSPP, 76, 7},
{ DBGBUS_DSPP, 88, 1},
{ DBGBUS_DSPP, 88, 2},
{ DBGBUS_DSPP, 88, 3},
{ DBGBUS_DSPP, 88, 4},
{ DBGBUS_DSPP, 88, 5},
{ DBGBUS_DSPP, 88, 6},
{ DBGBUS_DSPP, 88, 7},
{ DBGBUS_DSPP, 89, 1},
{ DBGBUS_DSPP, 89, 2},
{ DBGBUS_DSPP, 89, 3},
{ DBGBUS_DSPP, 89, 4},
{ DBGBUS_DSPP, 89, 5},
{ DBGBUS_DSPP, 89, 6},
{ DBGBUS_DSPP, 89, 7},
{ DBGBUS_DSPP, 90, 1},
{ DBGBUS_DSPP, 90, 2},
{ DBGBUS_DSPP, 90, 3},
{ DBGBUS_DSPP, 90, 4},
{ DBGBUS_DSPP, 90, 5},
{ DBGBUS_DSPP, 90, 6},
{ DBGBUS_DSPP, 90, 7},
{ DBGBUS_DSPP, 91, 1},
{ DBGBUS_DSPP, 91, 2},
{ DBGBUS_DSPP, 91, 3},
{ DBGBUS_DSPP, 91, 4},
{ DBGBUS_DSPP, 91, 5},
{ DBGBUS_DSPP, 91, 6},
{ DBGBUS_DSPP, 91, 7},
/* LM2 */
{ DBGBUS_DSPP, 77, 0},
{ DBGBUS_DSPP, 77, 1},
{ DBGBUS_DSPP, 77, 2},
{ DBGBUS_DSPP, 77, 3},
{ DBGBUS_DSPP, 77, 4},
{ DBGBUS_DSPP, 77, 5},
{ DBGBUS_DSPP, 77, 6},
{ DBGBUS_DSPP, 77, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 78, 0},
{ DBGBUS_DSPP, 78, 1},
{ DBGBUS_DSPP, 78, 2},
{ DBGBUS_DSPP, 78, 3},
{ DBGBUS_DSPP, 78, 4},
{ DBGBUS_DSPP, 78, 5},
{ DBGBUS_DSPP, 78, 6},
{ DBGBUS_DSPP, 78, 7},
{ DBGBUS_DSPP, 79, 0},
{ DBGBUS_DSPP, 79, 1},
{ DBGBUS_DSPP, 79, 2},
{ DBGBUS_DSPP, 79, 3},
{ DBGBUS_DSPP, 79, 4},
{ DBGBUS_DSPP, 79, 5},
{ DBGBUS_DSPP, 79, 6},
{ DBGBUS_DSPP, 79, 7},
{ DBGBUS_DSPP, 80, 0},
{ DBGBUS_DSPP, 80, 1},
{ DBGBUS_DSPP, 80, 2},
{ DBGBUS_DSPP, 80, 3},
{ DBGBUS_DSPP, 80, 4},
{ DBGBUS_DSPP, 80, 5},
{ DBGBUS_DSPP, 80, 6},
{ DBGBUS_DSPP, 80, 7},
{ DBGBUS_DSPP, 81, 0},
{ DBGBUS_DSPP, 81, 1},
{ DBGBUS_DSPP, 81, 2},
{ DBGBUS_DSPP, 81, 3},
{ DBGBUS_DSPP, 81, 4},
{ DBGBUS_DSPP, 81, 5},
{ DBGBUS_DSPP, 81, 6},
{ DBGBUS_DSPP, 81, 7},
{ DBGBUS_DSPP, 82, 0},
{ DBGBUS_DSPP, 82, 1},
{ DBGBUS_DSPP, 82, 2},
{ DBGBUS_DSPP, 82, 3},
{ DBGBUS_DSPP, 82, 4},
{ DBGBUS_DSPP, 82, 5},
{ DBGBUS_DSPP, 82, 6},
{ DBGBUS_DSPP, 82, 7},
{ DBGBUS_DSPP, 83, 0},
{ DBGBUS_DSPP, 83, 1},
{ DBGBUS_DSPP, 83, 2},
{ DBGBUS_DSPP, 83, 3},
{ DBGBUS_DSPP, 83, 4},
{ DBGBUS_DSPP, 83, 5},
{ DBGBUS_DSPP, 83, 6},
{ DBGBUS_DSPP, 83, 7},
{ DBGBUS_DSPP, 92, 1},
{ DBGBUS_DSPP, 92, 2},
{ DBGBUS_DSPP, 92, 3},
{ DBGBUS_DSPP, 92, 4},
{ DBGBUS_DSPP, 92, 5},
{ DBGBUS_DSPP, 92, 6},
{ DBGBUS_DSPP, 92, 7},
{ DBGBUS_DSPP, 93, 1},
{ DBGBUS_DSPP, 93, 2},
{ DBGBUS_DSPP, 93, 3},
{ DBGBUS_DSPP, 93, 4},
{ DBGBUS_DSPP, 93, 5},
{ DBGBUS_DSPP, 93, 6},
{ DBGBUS_DSPP, 93, 7},
{ DBGBUS_DSPP, 94, 1},
{ DBGBUS_DSPP, 94, 2},
{ DBGBUS_DSPP, 94, 3},
{ DBGBUS_DSPP, 94, 4},
{ DBGBUS_DSPP, 94, 5},
{ DBGBUS_DSPP, 94, 6},
{ DBGBUS_DSPP, 94, 7},
{ DBGBUS_DSPP, 95, 1},
{ DBGBUS_DSPP, 95, 2},
{ DBGBUS_DSPP, 95, 3},
{ DBGBUS_DSPP, 95, 4},
{ DBGBUS_DSPP, 95, 5},
{ DBGBUS_DSPP, 95, 6},
{ DBGBUS_DSPP, 95, 7},
/* LM3 */
{ DBGBUS_DSPP, 110, 1},
{ DBGBUS_DSPP, 110, 2},
{ DBGBUS_DSPP, 110, 3},
{ DBGBUS_DSPP, 110, 4},
{ DBGBUS_DSPP, 110, 5},
{ DBGBUS_DSPP, 110, 6},
{ DBGBUS_DSPP, 110, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 111, 1},
{ DBGBUS_DSPP, 111, 2},
{ DBGBUS_DSPP, 111, 3},
{ DBGBUS_DSPP, 111, 4},
{ DBGBUS_DSPP, 111, 5},
{ DBGBUS_DSPP, 111, 6},
{ DBGBUS_DSPP, 111, 7},
{ DBGBUS_DSPP, 112, 1},
{ DBGBUS_DSPP, 112, 2},
{ DBGBUS_DSPP, 112, 3},
{ DBGBUS_DSPP, 112, 4},
{ DBGBUS_DSPP, 112, 5},
{ DBGBUS_DSPP, 112, 6},
{ DBGBUS_DSPP, 112, 7},
{ DBGBUS_DSPP, 113, 1},
{ DBGBUS_DSPP, 113, 2},
{ DBGBUS_DSPP, 113, 3},
{ DBGBUS_DSPP, 113, 4},
{ DBGBUS_DSPP, 113, 5},
{ DBGBUS_DSPP, 113, 6},
{ DBGBUS_DSPP, 113, 7},
{ DBGBUS_DSPP, 114, 1},
{ DBGBUS_DSPP, 114, 2},
{ DBGBUS_DSPP, 114, 3},
{ DBGBUS_DSPP, 114, 4},
{ DBGBUS_DSPP, 114, 5},
{ DBGBUS_DSPP, 114, 6},
{ DBGBUS_DSPP, 114, 7},
{ DBGBUS_DSPP, 115, 1},
{ DBGBUS_DSPP, 115, 2},
{ DBGBUS_DSPP, 115, 3},
{ DBGBUS_DSPP, 115, 4},
{ DBGBUS_DSPP, 115, 5},
{ DBGBUS_DSPP, 115, 6},
{ DBGBUS_DSPP, 115, 7},
{ DBGBUS_DSPP, 116, 1},
{ DBGBUS_DSPP, 116, 2},
{ DBGBUS_DSPP, 116, 3},
{ DBGBUS_DSPP, 116, 4},
{ DBGBUS_DSPP, 116, 5},
{ DBGBUS_DSPP, 116, 6},
{ DBGBUS_DSPP, 116, 7},
{ DBGBUS_DSPP, 117, 1},
{ DBGBUS_DSPP, 117, 2},
{ DBGBUS_DSPP, 117, 3},
{ DBGBUS_DSPP, 117, 4},
{ DBGBUS_DSPP, 117, 5},
{ DBGBUS_DSPP, 117, 6},
{ DBGBUS_DSPP, 117, 7},
{ DBGBUS_DSPP, 118, 1},
{ DBGBUS_DSPP, 118, 2},
{ DBGBUS_DSPP, 118, 3},
{ DBGBUS_DSPP, 118, 4},
{ DBGBUS_DSPP, 118, 5},
{ DBGBUS_DSPP, 118, 6},
{ DBGBUS_DSPP, 118, 7},
{ DBGBUS_DSPP, 119, 1},
{ DBGBUS_DSPP, 119, 2},
{ DBGBUS_DSPP, 119, 3},
{ DBGBUS_DSPP, 119, 4},
{ DBGBUS_DSPP, 119, 5},
{ DBGBUS_DSPP, 119, 6},
{ DBGBUS_DSPP, 119, 7},
{ DBGBUS_DSPP, 120, 1},
{ DBGBUS_DSPP, 120, 2},
{ DBGBUS_DSPP, 120, 3},
{ DBGBUS_DSPP, 120, 4},
{ DBGBUS_DSPP, 120, 5},
{ DBGBUS_DSPP, 120, 6},
{ DBGBUS_DSPP, 120, 7},
/* LM4 */
{ DBGBUS_DSPP, 96, 1},
{ DBGBUS_DSPP, 96, 2},
{ DBGBUS_DSPP, 96, 3},
{ DBGBUS_DSPP, 96, 4},
{ DBGBUS_DSPP, 96, 5},
{ DBGBUS_DSPP, 96, 6},
{ DBGBUS_DSPP, 96, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 97, 1},
{ DBGBUS_DSPP, 97, 2},
{ DBGBUS_DSPP, 97, 3},
{ DBGBUS_DSPP, 97, 4},
{ DBGBUS_DSPP, 97, 5},
{ DBGBUS_DSPP, 97, 6},
{ DBGBUS_DSPP, 97, 7},
{ DBGBUS_DSPP, 98, 1},
{ DBGBUS_DSPP, 98, 2},
{ DBGBUS_DSPP, 98, 3},
{ DBGBUS_DSPP, 98, 4},
{ DBGBUS_DSPP, 98, 5},
{ DBGBUS_DSPP, 98, 6},
{ DBGBUS_DSPP, 98, 7},
{ DBGBUS_DSPP, 99, 1},
{ DBGBUS_DSPP, 99, 2},
{ DBGBUS_DSPP, 99, 3},
{ DBGBUS_DSPP, 99, 4},
{ DBGBUS_DSPP, 99, 5},
{ DBGBUS_DSPP, 99, 6},
{ DBGBUS_DSPP, 99, 7},
{ DBGBUS_DSPP, 100, 1},
{ DBGBUS_DSPP, 100, 2},
{ DBGBUS_DSPP, 100, 3},
{ DBGBUS_DSPP, 100, 4},
{ DBGBUS_DSPP, 100, 5},
{ DBGBUS_DSPP, 100, 6},
{ DBGBUS_DSPP, 100, 7},
{ DBGBUS_DSPP, 101, 1},
{ DBGBUS_DSPP, 101, 2},
{ DBGBUS_DSPP, 101, 3},
{ DBGBUS_DSPP, 101, 4},
{ DBGBUS_DSPP, 101, 5},
{ DBGBUS_DSPP, 101, 6},
{ DBGBUS_DSPP, 101, 7},
{ DBGBUS_DSPP, 103, 1},
{ DBGBUS_DSPP, 103, 2},
{ DBGBUS_DSPP, 103, 3},
{ DBGBUS_DSPP, 103, 4},
{ DBGBUS_DSPP, 103, 5},
{ DBGBUS_DSPP, 103, 6},
{ DBGBUS_DSPP, 103, 7},
{ DBGBUS_DSPP, 105, 1},
{ DBGBUS_DSPP, 105, 2},
{ DBGBUS_DSPP, 105, 3},
{ DBGBUS_DSPP, 105, 4},
{ DBGBUS_DSPP, 105, 5},
{ DBGBUS_DSPP, 105, 6},
{ DBGBUS_DSPP, 105, 7},
{ DBGBUS_DSPP, 106, 1},
{ DBGBUS_DSPP, 106, 2},
{ DBGBUS_DSPP, 106, 3},
{ DBGBUS_DSPP, 106, 4},
{ DBGBUS_DSPP, 106, 5},
{ DBGBUS_DSPP, 106, 6},
{ DBGBUS_DSPP, 106, 7},
{ DBGBUS_DSPP, 109, 1},
{ DBGBUS_DSPP, 109, 2},
{ DBGBUS_DSPP, 109, 3},
{ DBGBUS_DSPP, 109, 4},
{ DBGBUS_DSPP, 109, 5},
{ DBGBUS_DSPP, 109, 6},
{ DBGBUS_DSPP, 109, 7},
{ DBGBUS_DSPP, 122, 1},
{ DBGBUS_DSPP, 122, 2},
{ DBGBUS_DSPP, 122, 3},
{ DBGBUS_DSPP, 122, 4},
{ DBGBUS_DSPP, 122, 5},
{ DBGBUS_DSPP, 122, 6},
{ DBGBUS_DSPP, 122, 7},
/* LM5 */
{ DBGBUS_DSPP, 124, 1},
{ DBGBUS_DSPP, 124, 2},
{ DBGBUS_DSPP, 124, 3},
{ DBGBUS_DSPP, 124, 4},
{ DBGBUS_DSPP, 124, 5},
{ DBGBUS_DSPP, 124, 6},
{ DBGBUS_DSPP, 124, 7, _sde_debug_bus_lm_dump },
{ DBGBUS_DSPP, 125, 1},
{ DBGBUS_DSPP, 125, 2},
{ DBGBUS_DSPP, 125, 3},
{ DBGBUS_DSPP, 125, 4},
{ DBGBUS_DSPP, 125, 5},
{ DBGBUS_DSPP, 125, 6},
{ DBGBUS_DSPP, 125, 7},
{ DBGBUS_DSPP, 126, 1},
{ DBGBUS_DSPP, 126, 2},
{ DBGBUS_DSPP, 126, 3},
{ DBGBUS_DSPP, 126, 4},
{ DBGBUS_DSPP, 126, 5},
{ DBGBUS_DSPP, 126, 6},
{ DBGBUS_DSPP, 126, 7},
{ DBGBUS_DSPP, 127, 1},
{ DBGBUS_DSPP, 127, 2},
{ DBGBUS_DSPP, 127, 3},
{ DBGBUS_DSPP, 127, 4},
{ DBGBUS_DSPP, 127, 5},
{ DBGBUS_DSPP, 127, 6},
{ DBGBUS_DSPP, 127, 7},
{ DBGBUS_DSPP, 128, 1},
{ DBGBUS_DSPP, 128, 2},
{ DBGBUS_DSPP, 128, 3},
{ DBGBUS_DSPP, 128, 4},
{ DBGBUS_DSPP, 128, 5},
{ DBGBUS_DSPP, 128, 6},
{ DBGBUS_DSPP, 128, 7},
{ DBGBUS_DSPP, 129, 1},
{ DBGBUS_DSPP, 129, 2},
{ DBGBUS_DSPP, 129, 3},
{ DBGBUS_DSPP, 129, 4},
{ DBGBUS_DSPP, 129, 5},
{ DBGBUS_DSPP, 129, 6},
{ DBGBUS_DSPP, 129, 7},
{ DBGBUS_DSPP, 131, 1},
{ DBGBUS_DSPP, 131, 2},
{ DBGBUS_DSPP, 131, 3},
{ DBGBUS_DSPP, 131, 4},
{ DBGBUS_DSPP, 131, 5},
{ DBGBUS_DSPP, 131, 6},
{ DBGBUS_DSPP, 131, 7},
{ DBGBUS_DSPP, 132, 1},
{ DBGBUS_DSPP, 132, 2},
{ DBGBUS_DSPP, 132, 3},
{ DBGBUS_DSPP, 132, 4},
{ DBGBUS_DSPP, 132, 5},
{ DBGBUS_DSPP, 132, 6},
{ DBGBUS_DSPP, 132, 7},
{ DBGBUS_DSPP, 133, 1},
{ DBGBUS_DSPP, 133, 2},
{ DBGBUS_DSPP, 133, 3},
{ DBGBUS_DSPP, 133, 4},
{ DBGBUS_DSPP, 133, 5},
{ DBGBUS_DSPP, 133, 6},
{ DBGBUS_DSPP, 133, 7},
{ DBGBUS_DSPP, 134, 1},
{ DBGBUS_DSPP, 134, 2},
{ DBGBUS_DSPP, 134, 3},
{ DBGBUS_DSPP, 134, 4},
{ DBGBUS_DSPP, 134, 5},
{ DBGBUS_DSPP, 134, 6},
{ DBGBUS_DSPP, 134, 7},
{ DBGBUS_DSPP, 135, 1},
{ DBGBUS_DSPP, 135, 2},
{ DBGBUS_DSPP, 135, 3},
{ DBGBUS_DSPP, 135, 4},
{ DBGBUS_DSPP, 135, 5},
{ DBGBUS_DSPP, 135, 6},
{ DBGBUS_DSPP, 135, 7},
/* csc */
{ DBGBUS_SSPP0, 7, 0},
{ DBGBUS_SSPP0, 7, 1},
{ DBGBUS_SSPP0, 7, 2},
{ DBGBUS_SSPP0, 27, 0},
{ DBGBUS_SSPP0, 27, 1},
{ DBGBUS_SSPP0, 27, 2},
{ DBGBUS_SSPP1, 7, 0},
{ DBGBUS_SSPP1, 7, 1},
{ DBGBUS_SSPP1, 7, 2},
{ DBGBUS_SSPP1, 27, 0},
{ DBGBUS_SSPP1, 27, 1},
{ DBGBUS_SSPP1, 27, 2},
/* pcc */
{ DBGBUS_SSPP0, 43, 3},
{ DBGBUS_SSPP0, 47, 3},
{ DBGBUS_SSPP1, 43, 3},
{ DBGBUS_SSPP1, 47, 3},
/* spa */
{ DBGBUS_SSPP0, 8, 0},
{ DBGBUS_SSPP0, 28, 0},
{ DBGBUS_SSPP1, 8, 0},
{ DBGBUS_SSPP1, 28, 0},
/* dspp pa */
{ DBGBUS_DSPP, 13, 0},
{ DBGBUS_DSPP, 19, 0},
{ DBGBUS_DSPP, 24, 0},
{ DBGBUS_DSPP, 37, 0},
/* igc */
{ DBGBUS_SSPP0, 39, 0},
{ DBGBUS_SSPP0, 39, 1},
{ DBGBUS_SSPP0, 39, 2},
{ DBGBUS_SSPP1, 39, 0},
{ DBGBUS_SSPP1, 39, 1},
{ DBGBUS_SSPP1, 39, 2},
{ DBGBUS_SSPP0, 46, 0},
{ DBGBUS_SSPP0, 46, 1},
{ DBGBUS_SSPP0, 46, 2},
{ DBGBUS_SSPP1, 46, 0},
{ DBGBUS_SSPP1, 46, 1},
{ DBGBUS_SSPP1, 46, 2},
{ DBGBUS_DSPP, 14, 0},
{ DBGBUS_DSPP, 14, 1},
{ DBGBUS_DSPP, 14, 2},
{ DBGBUS_DSPP, 20, 0},
{ DBGBUS_DSPP, 20, 1},
{ DBGBUS_DSPP, 20, 2},
{ DBGBUS_DSPP, 25, 0},
{ DBGBUS_DSPP, 25, 1},
{ DBGBUS_DSPP, 25, 2},
{ DBGBUS_DSPP, 38, 0},
{ DBGBUS_DSPP, 38, 1},
{ DBGBUS_DSPP, 38, 2},
/* intf0-3 */
{ DBGBUS_PERIPH, 0, 0},
{ DBGBUS_PERIPH, 1, 0},
{ DBGBUS_PERIPH, 2, 0},
{ DBGBUS_PERIPH, 3, 0},
{ DBGBUS_PERIPH, 4, 0},
{ DBGBUS_PERIPH, 5, 0},
/* te counter wrapper */
{ DBGBUS_PERIPH, 60, 0},
{ DBGBUS_PERIPH, 60, 1},
{ DBGBUS_PERIPH, 60, 2},
{ DBGBUS_PERIPH, 60, 3},
{ DBGBUS_PERIPH, 60, 4},
{ DBGBUS_PERIPH, 60, 5},
/* dsc0 */
{ DBGBUS_PERIPH, 47, 0},
{ DBGBUS_PERIPH, 47, 1},
{ DBGBUS_PERIPH, 47, 2},
{ DBGBUS_PERIPH, 47, 3},
{ DBGBUS_PERIPH, 47, 4},
{ DBGBUS_PERIPH, 47, 5},
{ DBGBUS_PERIPH, 47, 6},
{ DBGBUS_PERIPH, 47, 7},
/* dsc1 */
{ DBGBUS_PERIPH, 48, 0},
{ DBGBUS_PERIPH, 48, 1},
{ DBGBUS_PERIPH, 48, 2},
{ DBGBUS_PERIPH, 48, 3},
{ DBGBUS_PERIPH, 48, 4},
{ DBGBUS_PERIPH, 48, 5},
{ DBGBUS_PERIPH, 48, 6},
{ DBGBUS_PERIPH, 48, 7},
/* dsc2 */
{ DBGBUS_PERIPH, 50, 0},
{ DBGBUS_PERIPH, 50, 1},
{ DBGBUS_PERIPH, 50, 2},
{ DBGBUS_PERIPH, 50, 3},
{ DBGBUS_PERIPH, 50, 4},
{ DBGBUS_PERIPH, 50, 5},
{ DBGBUS_PERIPH, 50, 6},
{ DBGBUS_PERIPH, 50, 7},
/* dsc3 */
{ DBGBUS_PERIPH, 51, 0},
{ DBGBUS_PERIPH, 51, 1},
{ DBGBUS_PERIPH, 51, 2},
{ DBGBUS_PERIPH, 51, 3},
{ DBGBUS_PERIPH, 51, 4},
{ DBGBUS_PERIPH, 51, 5},
{ DBGBUS_PERIPH, 51, 6},
{ DBGBUS_PERIPH, 51, 7},
/* dsc4 */
{ DBGBUS_PERIPH, 52, 0},
{ DBGBUS_PERIPH, 52, 1},
{ DBGBUS_PERIPH, 52, 2},
{ DBGBUS_PERIPH, 52, 3},
{ DBGBUS_PERIPH, 52, 4},
{ DBGBUS_PERIPH, 52, 5},
{ DBGBUS_PERIPH, 52, 6},
{ DBGBUS_PERIPH, 52, 7},
/* dsc5 */
{ DBGBUS_PERIPH, 53, 0},
{ DBGBUS_PERIPH, 53, 1},
{ DBGBUS_PERIPH, 53, 2},
{ DBGBUS_PERIPH, 53, 3},
{ DBGBUS_PERIPH, 53, 4},
{ DBGBUS_PERIPH, 53, 5},
{ DBGBUS_PERIPH, 53, 6},
{ DBGBUS_PERIPH, 53, 7},
/* tear-check */
/* INTF_0 */
{ DBGBUS_PERIPH, 63, 0 },
{ DBGBUS_PERIPH, 63, 1 },
{ DBGBUS_PERIPH, 63, 2 },
{ DBGBUS_PERIPH, 63, 3 },
{ DBGBUS_PERIPH, 63, 4 },
{ DBGBUS_PERIPH, 63, 5 },
{ DBGBUS_PERIPH, 63, 6 },
{ DBGBUS_PERIPH, 63, 7 },
/* INTF_1 */
{ DBGBUS_PERIPH, 64, 0 },
{ DBGBUS_PERIPH, 64, 1 },
{ DBGBUS_PERIPH, 64, 2 },
{ DBGBUS_PERIPH, 64, 3 },
{ DBGBUS_PERIPH, 64, 4 },
{ DBGBUS_PERIPH, 64, 5 },
{ DBGBUS_PERIPH, 64, 6 },
{ DBGBUS_PERIPH, 64, 7 },
/* INTF_2 */
{ DBGBUS_PERIPH, 65, 0 },
{ DBGBUS_PERIPH, 65, 1 },
{ DBGBUS_PERIPH, 65, 2 },
{ DBGBUS_PERIPH, 65, 3 },
{ DBGBUS_PERIPH, 65, 4 },
{ DBGBUS_PERIPH, 65, 5 },
{ DBGBUS_PERIPH, 65, 6 },
{ DBGBUS_PERIPH, 65, 7 },
/* INTF_4 */
{ DBGBUS_PERIPH, 66, 0 },
{ DBGBUS_PERIPH, 66, 1 },
{ DBGBUS_PERIPH, 66, 2 },
{ DBGBUS_PERIPH, 66, 3 },
{ DBGBUS_PERIPH, 66, 4 },
{ DBGBUS_PERIPH, 66, 5 },
{ DBGBUS_PERIPH, 66, 6 },
{ DBGBUS_PERIPH, 66, 7 },
/* INTF_5 */
{ DBGBUS_PERIPH, 67, 0 },
{ DBGBUS_PERIPH, 67, 1 },
{ DBGBUS_PERIPH, 67, 2 },
{ DBGBUS_PERIPH, 67, 3 },
{ DBGBUS_PERIPH, 67, 4 },
{ DBGBUS_PERIPH, 67, 5 },
{ DBGBUS_PERIPH, 67, 6 },
{ DBGBUS_PERIPH, 67, 7 },
/* INTF_3 */
{ DBGBUS_PERIPH, 73, 0 },
{ DBGBUS_PERIPH, 73, 1 },
{ DBGBUS_PERIPH, 73, 2 },
{ DBGBUS_PERIPH, 73, 3 },
{ DBGBUS_PERIPH, 73, 4 },
{ DBGBUS_PERIPH, 73, 5 },
{ DBGBUS_PERIPH, 73, 6 },
{ DBGBUS_PERIPH, 73, 7 },
/* cdwn */
{ DBGBUS_PERIPH, 80, 0},
{ DBGBUS_PERIPH, 80, 1},
{ DBGBUS_PERIPH, 80, 2},
{ DBGBUS_PERIPH, 81, 0},
{ DBGBUS_PERIPH, 81, 1},
{ DBGBUS_PERIPH, 81, 2},
{ DBGBUS_PERIPH, 82, 0},
{ DBGBUS_PERIPH, 82, 1},
{ DBGBUS_PERIPH, 82, 2},
{ DBGBUS_PERIPH, 82, 3},
{ DBGBUS_PERIPH, 82, 4},
{ DBGBUS_PERIPH, 82, 5},
{ DBGBUS_PERIPH, 82, 6},
{ DBGBUS_PERIPH, 82, 7},
/* DPTX1 */
{ DBGBUS_PERIPH, 68, 0},
{ DBGBUS_PERIPH, 68, 1},
{ DBGBUS_PERIPH, 68, 2},
{ DBGBUS_PERIPH, 68, 3},
{ DBGBUS_PERIPH, 68, 4},
{ DBGBUS_PERIPH, 68, 5},
{ DBGBUS_PERIPH, 68, 6},
{ DBGBUS_PERIPH, 68, 7},
/* DP */
{ DBGBUS_PERIPH, 69, 0},
{ DBGBUS_PERIPH, 69, 1},
{ DBGBUS_PERIPH, 69, 2},
{ DBGBUS_PERIPH, 69, 3},
{ DBGBUS_PERIPH, 69, 4},
{ DBGBUS_PERIPH, 69, 5},
/* dsi0 */
{ DBGBUS_PERIPH, 70, 0},
{ DBGBUS_PERIPH, 70, 1},
{ DBGBUS_PERIPH, 70, 2},
{ DBGBUS_PERIPH, 70, 3},
{ DBGBUS_PERIPH, 70, 4},
{ DBGBUS_PERIPH, 70, 5},
/* dsi1 */
{ DBGBUS_PERIPH, 71, 0},
{ DBGBUS_PERIPH, 71, 1},
{ DBGBUS_PERIPH, 71, 2},
{ DBGBUS_PERIPH, 71, 3},
{ DBGBUS_PERIPH, 71, 4},
{ DBGBUS_PERIPH, 71, 5},
/* eDP */
{ DBGBUS_PERIPH, 72, 0},
{ DBGBUS_PERIPH, 72, 1},
{ DBGBUS_PERIPH, 72, 2},
{ DBGBUS_PERIPH, 72, 3},
{ DBGBUS_PERIPH, 72, 4},
{ DBGBUS_PERIPH, 72, 5},
};
static struct vbif_debug_bus_entry vbif_dbg_bus_msm8998[] = {
{0x214, 0x21c, 16, 2, 0x0, 0xd}, /* arb clients */
{0x214, 0x21c, 16, 2, 0x80, 0xc0}, /* arb clients */
{0x214, 0x21c, 16, 2, 0x100, 0x140}, /* arb clients */
{0x214, 0x21c, 0, 16, 0x0, 0xf}, /* xin blocks - axi side */
{0x214, 0x21c, 0, 16, 0x80, 0xa4}, /* xin blocks - axi side */
{0x214, 0x21c, 0, 15, 0x100, 0x124}, /* xin blocks - axi side */
{0x21c, 0x214, 0, 14, 0, 0xc}, /* xin blocks - clock side */
};
u32 dsi_dbg_bus_kona[] = {
0x0001, 0x1001, 0x0001, 0x0011,
0x1021, 0x0021, 0x0031, 0x0041,
0x0051, 0x0061, 0x3061, 0x0061,
0x2061, 0x2061, 0x1061, 0x1061,
0x1061, 0x0071, 0x0071, 0x0071,
0x0081, 0x0081, 0x00A1, 0x00A1,
0x10A1, 0x20A1, 0x30A1, 0x10A1,
0x10A1, 0x30A1, 0x20A1, 0x00B1,
0x00C1, 0x00C1, 0x10C1, 0x20C1,
0x30C1, 0x00D1, 0x00D1, 0x20D1,
0x30D1, 0x00E1, 0x00E1, 0x00E1,
0x00F1, 0x00F1, 0x0101, 0x0101,
0x1101, 0x2101, 0x3101, 0x0111,
0x0141, 0x1141, 0x0141, 0x1141,
0x1141, 0x0151, 0x0151, 0x1151,
0x2151, 0x3151, 0x0161, 0x0161,
0x1161, 0x0171, 0x0171, 0x0181,
0x0181, 0x0191, 0x0191, 0x01A1,
0x01A1, 0x01B1, 0x01B1, 0x11B1,
0x21B1, 0x01C1, 0x01C1, 0x11C1,
0x21C1, 0x31C1, 0x01D1, 0x01D1,
0x01D1, 0x01D1, 0x11D1, 0x21D1,
0x21D1, 0x01E1, 0x01E1, 0x01F1,
0x01F1, 0x0201, 0x0201, 0x0211,
0x0221, 0x0231, 0x0241, 0x0251,
0x0281, 0x0291, 0x0281, 0x0291,
0x02A1, 0x02B1, 0x02C1, 0x0321,
0x0321, 0x1321, 0x2321, 0x3321,
0x0331, 0x0331, 0x1331, 0x0341,
0x0341, 0x1341, 0x2341, 0x3341,
0x0351, 0x0361, 0x0361, 0x1361,
0x2361, 0x0371, 0x0381, 0x0391,
0x03C1, 0x03D1, 0x03E1, 0x03F1,
};
/**
* _sde_power_check - check if power needs to enabled
* @dump_mode: to check if power need to be enabled
* Return: true if success; false otherwise
*/
static inline bool _sde_power_check(enum sde_dbg_dump_context dump_mode)
{
return (dump_mode == SDE_DBG_DUMP_CLK_ENABLED_CTX ||
dump_mode == SDE_DBG_DUMP_IRQ_CTX) ? false : true;
}
/**
* _sde_dump_reg - helper function for dumping rotator register set content
* @dump_name: register set name
* @reg_dump_flag: dumping flag controlling in-log/memory dump location
* @base_addr: starting address of io region for calculating offsets to print
* @addr: starting address offset for dumping
* @len_bytes: range of the register set
* @dump_mem: output buffer for memory dump location option
* @from_isr: whether being called from isr context
*/
static void _sde_dump_reg(const char *dump_name, u32 reg_dump_flag,
char *base_addr, char *addr, size_t len_bytes, u32 **dump_mem)
{
u32 in_log, in_mem, len_align, len_padded;
u32 *dump_addr = NULL;
char *end_addr;
int i;
int rc;
if (!len_bytes)
return;
in_log = (reg_dump_flag & SDE_DBG_DUMP_IN_LOG);
in_mem = (reg_dump_flag & SDE_DBG_DUMP_IN_MEM);
pr_debug("%s: reg_dump_flag=%d in_log=%d in_mem=%d\n",
dump_name, reg_dump_flag, in_log, in_mem);
if (!in_log && !in_mem)
return;
if (in_log)
dev_info(sde_dbg_base.dev, "%s: start_offset 0x%lx len 0x%zx\n",
dump_name, (unsigned long)(addr - base_addr),
len_bytes);
len_align = (len_bytes + REG_DUMP_ALIGN - 1) / REG_DUMP_ALIGN;
len_padded = len_align * REG_DUMP_ALIGN;
end_addr = addr + len_bytes;
if (in_mem) {
if (dump_mem && !(*dump_mem)) {
phys_addr_t phys = 0;
*dump_mem = dma_alloc_coherent(sde_dbg_base.dev,
len_padded, &phys, GFP_KERNEL);
}
if (dump_mem && *dump_mem) {
dump_addr = *dump_mem;
dev_info(sde_dbg_base.dev,
"%s: start_addr:0x%pK len:0x%x reg_offset=0x%lx\n",
dump_name, dump_addr, len_padded,
(unsigned long)(addr - base_addr));
} else {
in_mem = 0;
pr_err("dump_mem: kzalloc fails!\n");
}
}
if (_sde_power_check(sde_dbg_base.dump_mode)) {
rc = pm_runtime_get_sync(sde_dbg_base.dev);
if (rc < 0) {
pr_err("failed to enable power %d\n", rc);
return;
}
}
for (i = 0; i < len_align; i++) {
u32 x0, x4, x8, xc;
x0 = (addr < end_addr) ? readl_relaxed(addr + 0x0) : 0;
x4 = (addr + 0x4 < end_addr) ? readl_relaxed(addr + 0x4) : 0;
x8 = (addr + 0x8 < end_addr) ? readl_relaxed(addr + 0x8) : 0;
xc = (addr + 0xc < end_addr) ? readl_relaxed(addr + 0xc) : 0;
if (in_log)
dev_info(sde_dbg_base.dev,
"0x%lx : %08x %08x %08x %08x\n",
(unsigned long)(addr - base_addr),
x0, x4, x8, xc);
if (dump_addr) {
dump_addr[i * 4] = x0;
dump_addr[i * 4 + 1] = x4;
dump_addr[i * 4 + 2] = x8;
dump_addr[i * 4 + 3] = xc;
}
addr += REG_DUMP_ALIGN;
}
if (_sde_power_check(sde_dbg_base.dump_mode))
pm_runtime_put_sync(sde_dbg_base.dev);
}
/**
* _sde_dbg_get_dump_range - helper to retrieve dump length for a range node
* @range_node: range node to dump
* @max_offset: max offset of the register base
* @Return: length
*/
static u32 _sde_dbg_get_dump_range(struct sde_dbg_reg_offset *range_node,
size_t max_offset)
{
u32 length = 0;
if (range_node->start == 0 && range_node->end == 0) {
length = max_offset;
} else if (range_node->start < max_offset) {
if (range_node->end > max_offset)
length = max_offset - range_node->start;
else if (range_node->start < range_node->end)
length = range_node->end - range_node->start;
}
return length;
}
static int _sde_dump_reg_range_cmp(void *priv, struct list_head *a,
struct list_head *b)
{
struct sde_dbg_reg_range *ar, *br;
if (!a || !b)
return 0;
ar = container_of(a, struct sde_dbg_reg_range, head);
br = container_of(b, struct sde_dbg_reg_range, head);
return ar->offset.start - br->offset.start;
}
static const char *const exclude_modules[] = {
"vbif_rt",
"vbif_nrt",
"wb_2",
NULL
};
static bool is_block_exclude(char **modules, char *name)
{
char **ptr = modules;
while (*ptr != NULL) {
if (!strcmp(name, *ptr))
return true;
++ptr;
}
return false;
}
/**
* _sde_dump_reg_by_ranges - dump ranges or full range of the register blk base
* @dbg: register blk base structure
* @reg_dump_flag: dump target, memory, kernel log, or both
* @dump_secure: flag to indicate dumping in secure-session
*/
static void _sde_dump_reg_by_ranges(struct sde_dbg_reg_base *dbg,
u32 reg_dump_flag, bool dump_secure)
{
char *addr;
size_t len;
struct sde_dbg_reg_range *range_node;
if (!dbg || !(dbg->base || dbg->cb)) {
pr_err("dbg base is null!\n");
return;
}
dev_info(sde_dbg_base.dev, "%s:=========%s DUMP=========\n", __func__,
dbg->name);
if (dbg->cb) {
dbg->cb(dbg->cb_ptr);
/* If there is a list to dump the registers by ranges, use the ranges */
} else if (!list_empty(&dbg->sub_range_list)) {
/* sort the list by start address first */
list_sort(NULL, &dbg->sub_range_list, _sde_dump_reg_range_cmp);
list_for_each_entry(range_node, &dbg->sub_range_list, head) {
len = _sde_dbg_get_dump_range(&range_node->offset,
dbg->max_offset);
addr = dbg->base + range_node->offset.start;
if (dump_secure &&
is_block_exclude((char**)exclude_modules,
range_node->range_name))
continue;
pr_debug("%s: range_base=0x%pK start=0x%x end=0x%x\n",
range_node->range_name,
addr, range_node->offset.start,
range_node->offset.end);
_sde_dump_reg(range_node->range_name, reg_dump_flag,
dbg->base, addr, len,
&range_node->reg_dump);
}
} else {
/* If there is no list to dump ranges, dump all registers */
dev_info(sde_dbg_base.dev,
"Ranges not found, will dump full registers\n");
dev_info(sde_dbg_base.dev, "base:0x%pK len:0x%zx\n", dbg->base,
dbg->max_offset);
addr = dbg->base;
len = dbg->max_offset;
_sde_dump_reg(dbg->name, reg_dump_flag, dbg->base, addr, len,
&dbg->reg_dump);
}
}
/**
* _sde_dump_reg_by_blk - dump a named register base region
* @blk_name: register blk name
* @dump_secure: flag to indicate dumping in secure-session
*/
static void _sde_dump_reg_by_blk(const char *blk_name, bool dump_secure)
{
struct sde_dbg_base *dbg_base = &sde_dbg_base;
struct sde_dbg_reg_base *blk_base;
if (!dbg_base)
return;
list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head) {
if (strlen(blk_base->name) &&
!strcmp(blk_base->name, blk_name)) {
_sde_dump_reg_by_ranges(blk_base,
dbg_base->enable_reg_dump, dump_secure);
break;
}
}
}
/**
* _sde_dump_reg_all - dump all register regions
*/
static void _sde_dump_reg_all(bool dump_secure)
{
struct sde_dbg_base *dbg_base = &sde_dbg_base;
struct sde_dbg_reg_base *blk_base;
if (!dbg_base)
return;
list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head) {
if (!strlen(blk_base->name))
continue;
if (dump_secure &&
is_block_exclude((char **)exclude_modules,
blk_base->name))
continue;
_sde_dump_reg_by_blk(blk_base->name, dump_secure);
}
}
/**
* _sde_dump_get_blk_addr - retrieve register block address by name
* @blk_name: register blk name
* @Return: register blk base, or NULL
*/
static struct sde_dbg_reg_base *_sde_dump_get_blk_addr(const char *blk_name)
{
struct sde_dbg_base *dbg_base = &sde_dbg_base;
struct sde_dbg_reg_base *blk_base;
list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head)
if (strlen(blk_base->name) && !strcmp(blk_base->name, blk_name))
return blk_base;
return NULL;
}
static void _sde_dbg_dump_sde_dbg_bus(struct sde_dbg_sde_debug_bus *bus)
{
bool in_log, in_mem;
u32 **dump_mem = NULL;
u32 *dump_addr = NULL;
u32 status = 0;
struct sde_debug_bus_entry *head;
phys_addr_t phys = 0;
int list_size;
int i;
u32 offset;
void __iomem *mem_base = NULL;
struct sde_dbg_reg_base *reg_base;
int rc;
if (!bus || !bus->cmn.entries_size)
return;
list_for_each_entry(reg_base, &sde_dbg_base.reg_base_list,
reg_base_head)
if (strlen(reg_base->name) &&
!strcmp(reg_base->name, bus->cmn.name))
mem_base = reg_base->base + bus->top_blk_off;
if (!mem_base) {
pr_err("unable to find mem_base for %s\n", bus->cmn.name);
return;
}
dump_mem = &bus->cmn.dumped_content;
/* will keep in memory 4 entries of 4 bytes each */
list_size = (bus->cmn.entries_size * 4 * 4);
in_log = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_LOG);
in_mem = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_MEM);
if (!in_log && !in_mem)
return;
dev_info(sde_dbg_base.dev, "======== start %s dump =========\n",
bus->cmn.name);
if (in_mem) {
if (!(*dump_mem))
*dump_mem = dma_alloc_coherent(sde_dbg_base.dev,
list_size, &phys, GFP_KERNEL);
if (*dump_mem) {
dump_addr = *dump_mem;
dev_info(sde_dbg_base.dev,
"%s: start_addr:0x%pK len:0x%x\n",
__func__, dump_addr, list_size);
} else {
in_mem = false;
pr_err("dump_mem: allocation fails\n");
}
}
rc = pm_runtime_get_sync(sde_dbg_base.dev);
if (rc < 0) {
pr_err("failed to enable power %d\n", rc);
return;
}
for (i = 0; i < bus->cmn.entries_size; i++) {
head = bus->entries + i;
if (head->test_id > 0x7)
writel_relaxed(TEST_EXT_MASK(head->block_id,
head->test_id), mem_base + head->wr_addr);
else
writel_relaxed(TEST_MASK(head->block_id, head->test_id),
mem_base + head->wr_addr);
wmb(); /* make sure test bits were written */
if (bus->cmn.flags & DBGBUS_FLAGS_DSPP) {
offset = DBGBUS_DSPP_STATUS;
/* keep DSPP test point enabled */
if (head->wr_addr != DBGBUS_DSPP)
writel_relaxed(0x7001, mem_base + DBGBUS_DSPP);
} else {
offset = head->wr_addr + 0x4;
}
status = readl_relaxed(mem_base + offset);
if (in_log)
dev_info(sde_dbg_base.dev,
"waddr=0x%x blk=%d tst=%d val=0x%x\n",
head->wr_addr, head->block_id,
head->test_id, status);
if (dump_addr && in_mem) {
dump_addr[i*4] = head->wr_addr;
dump_addr[i*4 + 1] = head->block_id;
dump_addr[i*4 + 2] = head->test_id;
dump_addr[i*4 + 3] = status;
}
if (head->analyzer)
head->analyzer(mem_base, head, status);
/* Disable debug bus once we are done */
writel_relaxed(0, mem_base + head->wr_addr);
if (bus->cmn.flags & DBGBUS_FLAGS_DSPP &&
head->wr_addr != DBGBUS_DSPP)
writel_relaxed(0x0, mem_base + DBGBUS_DSPP);
}
pm_runtime_put_sync(sde_dbg_base.dev);
dev_info(sde_dbg_base.dev, "======== end %s dump =========\n",
bus->cmn.name);
}
static void _sde_dbg_dump_vbif_debug_bus_entry(
struct vbif_debug_bus_entry *head, void __iomem *mem_base,
u32 *dump_addr, bool in_log)
{
int i, j;
u32 val;
if (!dump_addr && !in_log)
return;
for (i = 0; i < head->block_cnt; i++) {
writel_relaxed(1 << (i + head->bit_offset),
mem_base + head->block_bus_addr);
/* make sure that current bus blcok enable */
wmb();
for (j = head->test_pnt_start; j < head->test_pnt_cnt; j++) {
writel_relaxed(j, mem_base + head->block_bus_addr + 4);
/* make sure that test point is enabled */
wmb();
val = readl_relaxed(mem_base + MMSS_VBIF_TEST_BUS_OUT);
if (dump_addr) {
*dump_addr++ = head->block_bus_addr;
*dump_addr++ = i;
*dump_addr++ = j;
*dump_addr++ = val;
}
if (in_log)
dev_info(sde_dbg_base.dev,
"testpoint:%x arb/xin id=%d index=%d val=0x%x\n",
head->block_bus_addr, i, j, val);
}
}
}
static void _sde_dbg_dump_vbif_dbg_bus(struct sde_dbg_vbif_debug_bus *bus)
{
bool in_log, in_mem;
u32 **dump_mem = NULL;
u32 *dump_addr = NULL;
u32 value, d0, d1;
unsigned long reg, reg1, reg2;
struct vbif_debug_bus_entry *head;
phys_addr_t phys = 0;
int i, list_size = 0;
void __iomem *mem_base = NULL;
struct vbif_debug_bus_entry *dbg_bus;
u32 bus_size;
struct sde_dbg_reg_base *reg_base;
int rc;
if (!bus || !bus->cmn.entries_size)
return;
list_for_each_entry(reg_base, &sde_dbg_base.reg_base_list,
reg_base_head)
if (strlen(reg_base->name) &&
!strcmp(reg_base->name, bus->cmn.name))
mem_base = reg_base->base;
if (!mem_base) {
pr_err("unable to find mem_base for %s\n", bus->cmn.name);
return;
}
dbg_bus = bus->entries;
bus_size = bus->cmn.entries_size;
list_size = bus->cmn.entries_size;
dump_mem = &bus->cmn.dumped_content;
dev_info(sde_dbg_base.dev, "======== start %s dump =========\n",
bus->cmn.name);
if (!dump_mem || !dbg_bus || !bus_size || !list_size)
return;
/* allocate memory for each test point */
for (i = 0; i < bus_size; i++) {
head = dbg_bus + i;
list_size += (head->block_cnt * head->test_pnt_cnt);
}
/* 4 bytes * 4 entries for each test point*/
list_size *= 16;
in_log = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_LOG);
in_mem = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_MEM);
if (!in_log && !in_mem)
return;
if (in_mem) {
if (!(*dump_mem))
*dump_mem = dma_alloc_coherent(sde_dbg_base.dev,
list_size, &phys, GFP_KERNEL);
if (*dump_mem) {
dump_addr = *dump_mem;
dev_info(sde_dbg_base.dev,
"%s: start_addr:0x%pK len:0x%x\n",
__func__, dump_addr, list_size);
} else {
in_mem = false;
pr_err("dump_mem: allocation fails\n");
}
}
rc = pm_runtime_get_sync(sde_dbg_base.dev);
if (rc < 0) {
pr_err("failed to enable power %d\n", rc);
return;
}
value = readl_relaxed(mem_base + MMSS_VBIF_CLKON);
writel_relaxed(value | BIT(1), mem_base + MMSS_VBIF_CLKON);
/* make sure that vbif core is on */
wmb();
/**
* Extract VBIF error info based on XIN halt and error status.
* If the XIN client is not in HALT state, or an error is detected,
* then retrieve the VBIF error info for it.
*/
reg = readl_relaxed(mem_base + MMSS_VBIF_XIN_HALT_CTRL1);
reg1 = readl_relaxed(mem_base + MMSS_VBIF_PND_ERR);
reg2 = readl_relaxed(mem_base + MMSS_VBIF_SRC_ERR);
dev_err(sde_dbg_base.dev,
"XIN HALT:0x%lX, PND ERR:0x%lX, SRC ERR:0x%lX\n",
reg, reg1, reg2);
reg >>= 16;
reg &= ~(reg1 | reg2);
for (i = 0; i < MMSS_VBIF_CLIENT_NUM; i++) {
if (!test_bit(0, &reg)) {
writel_relaxed(i, mem_base + MMSS_VBIF_ERR_INFO);
/* make sure reg write goes through */
wmb();
d0 = readl_relaxed(mem_base + MMSS_VBIF_ERR_INFO);
d1 = readl_relaxed(mem_base + MMSS_VBIF_ERR_INFO_1);
dev_err(sde_dbg_base.dev,
"Client:%d, errinfo=0x%X, errinfo1=0x%X\n",
i, d0, d1);
}
reg >>= 1;
}
for (i = 0; i < bus_size; i++) {
head = dbg_bus + i;
writel_relaxed(0, mem_base + head->disable_bus_addr);
writel_relaxed(BIT(0), mem_base + MMSS_VBIF_TEST_BUS_OUT_CTRL);
/* make sure that other bus is off */
wmb();
_sde_dbg_dump_vbif_debug_bus_entry(head, mem_base, dump_addr,
in_log);
if (dump_addr)
dump_addr += (head->block_cnt * head->test_pnt_cnt * 4);
}
pm_runtime_put_sync(sde_dbg_base.dev);
dev_info(sde_dbg_base.dev, "======== end %s dump =========\n",
bus->cmn.name);
}
/**
* _sde_dump_array - dump array of register bases
* @blk_arr: array of register base pointers
* @len: length of blk_arr
* @do_panic: whether to trigger a panic after dumping
* @name: string indicating origin of dump
* @dump_dbgbus_sde: whether to dump the sde debug bus
* @dump_dbgbus_vbif_rt: whether to dump the vbif rt debug bus
* @dump_secure: flag to indicate dumping in secure-session
*/
static void _sde_dump_array(struct sde_dbg_reg_base *blk_arr[],
u32 len, bool do_panic, const char *name, bool dump_dbgbus_sde,
bool dump_dbgbus_vbif_rt, bool dump_all, bool dump_secure)
{
int i;
mutex_lock(&sde_dbg_base.mutex);
if (dump_all)
sde_evtlog_dump_all(sde_dbg_base.evtlog);
if (dump_all || !blk_arr || !len) {
_sde_dump_reg_all(dump_secure);
} else {
for (i = 0; i < len; i++) {
if (blk_arr[i] != NULL)
_sde_dump_reg_by_ranges(blk_arr[i],
sde_dbg_base.enable_reg_dump,
dump_secure);
}
}
if (dump_dbgbus_sde)
_sde_dbg_dump_sde_dbg_bus(&sde_dbg_base.dbgbus_sde);
if (dump_dbgbus_vbif_rt)
_sde_dbg_dump_vbif_dbg_bus(&sde_dbg_base.dbgbus_vbif_rt);
if (sde_dbg_base.dsi_dbg_bus || dump_all)
dsi_ctrl_debug_dump(sde_dbg_base.dbgbus_dsi.entries,
sde_dbg_base.dbgbus_dsi.size);
if (do_panic && sde_dbg_base.panic_on_err)
panic(name);
mutex_unlock(&sde_dbg_base.mutex);
}
/**
* _sde_dump_work - deferred dump work function
* @work: work structure
*/
static void _sde_dump_work(struct work_struct *work)
{
_sde_dump_array(sde_dbg_base.req_dump_blks,
ARRAY_SIZE(sde_dbg_base.req_dump_blks),
sde_dbg_base.work_panic, "evtlog_workitem",
sde_dbg_base.dbgbus_sde.cmn.include_in_deferred_work,
sde_dbg_base.dbgbus_vbif_rt.cmn.include_in_deferred_work,
sde_dbg_base.dump_all, sde_dbg_base.dump_secure);
}
void sde_dbg_dump(enum sde_dbg_dump_context dump_mode, const char *name, ...)
{
int i, index = 0;
bool do_panic = false;
bool dump_dbgbus_sde = false;
bool dump_dbgbus_vbif_rt = false;
bool dump_all = false;
bool dump_secure = false;
va_list args;
char *blk_name = NULL;
struct sde_dbg_reg_base *blk_base = NULL;
struct sde_dbg_reg_base **blk_arr;
u32 blk_len;
if (!sde_evtlog_is_enabled(sde_dbg_base.evtlog, SDE_EVTLOG_ALWAYS))
return;
if ((dump_mode == SDE_DBG_DUMP_IRQ_CTX) &&
work_pending(&sde_dbg_base.dump_work))
return;
blk_arr = &sde_dbg_base.req_dump_blks[0];
blk_len = ARRAY_SIZE(sde_dbg_base.req_dump_blks);
memset(sde_dbg_base.req_dump_blks, 0,
sizeof(sde_dbg_base.req_dump_blks));
sde_dbg_base.dump_all = false;
sde_dbg_base.dump_mode = dump_mode;
va_start(args, name);
i = 0;
while ((blk_name = va_arg(args, char*))) {
if (i++ >= SDE_EVTLOG_MAX_DATA) {
pr_err("could not parse all dump arguments\n");
break;
}
if (IS_ERR_OR_NULL(blk_name))
break;
blk_base = _sde_dump_get_blk_addr(blk_name);
if (blk_base) {
if (index < blk_len) {
blk_arr[index] = blk_base;
index++;
} else {
pr_err("insufficient space to to dump %s\n",
blk_name);
}
}
if (!strcmp(blk_name, "all"))
dump_all = true;
if (!strcmp(blk_name, "dbg_bus"))
dump_dbgbus_sde = true;
if (!strcmp(blk_name, "vbif_dbg_bus"))
dump_dbgbus_vbif_rt = true;
if (!strcmp(blk_name, "dsi_dbg_bus"))
sde_dbg_base.dsi_dbg_bus = true;
if (!strcmp(blk_name, "panic"))
do_panic = true;
if (!strcmp(blk_name, "secure"))
dump_secure = true;
}
va_end(args);
if (dump_mode == SDE_DBG_DUMP_IRQ_CTX) {
/* schedule work to dump later */
sde_dbg_base.work_panic = do_panic;
sde_dbg_base.dbgbus_sde.cmn.include_in_deferred_work =
dump_dbgbus_sde;
sde_dbg_base.dbgbus_vbif_rt.cmn.include_in_deferred_work =
dump_dbgbus_vbif_rt;
sde_dbg_base.dump_all = dump_all;
schedule_work(&sde_dbg_base.dump_work);
} else {
_sde_dump_array(blk_arr, blk_len, do_panic, name,
dump_dbgbus_sde, dump_dbgbus_vbif_rt,
dump_all, dump_secure);
}
}
void sde_dbg_ctrl(const char *name, ...)
{
int i = 0;
va_list args;
char *blk_name = NULL;
/* no debugfs controlled events are enabled, just return */
if (!sde_dbg_base.debugfs_ctrl)
return;
va_start(args, name);
while ((blk_name = va_arg(args, char*))) {
if (i++ >= SDE_EVTLOG_MAX_DATA) {
pr_err("could not parse all dbg arguments\n");
break;
}
if (IS_ERR_OR_NULL(blk_name))
break;
if (!strcmp(blk_name, "stop_ftrace") &&
sde_dbg_base.debugfs_ctrl &
DBG_CTRL_STOP_FTRACE) {
pr_debug("tracing off\n");
tracing_off();
}
if (!strcmp(blk_name, "panic_underrun") &&
sde_dbg_base.debugfs_ctrl &
DBG_CTRL_PANIC_UNDERRUN) {
pr_err("panic underrun\n");
SDE_DBG_DUMP_WQ("all", "dbg_bus", "vbif_dbg_bus",
"panic");
}
if (!strcmp(blk_name, "reset_hw_panic") &&
sde_dbg_base.debugfs_ctrl &
DBG_CTRL_RESET_HW_PANIC) {
pr_debug("reset hw panic\n");
panic("reset_hw");
}
}
va_end(args);
}
/*
* sde_dbg_debugfs_open - debugfs open handler for evtlog dump
* @inode: debugfs inode
* @file: file handle
*/
static int sde_dbg_debugfs_open(struct inode *inode, struct file *file)
{
if (!inode || !file)
return -EINVAL;
/* non-seekable */
file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
file->private_data = inode->i_private;
mutex_lock(&sde_dbg_base.mutex);
sde_dbg_base.cur_evt_index = 0;
sde_dbg_base.evtlog->first = sde_dbg_base.evtlog->curr + 1;
sde_dbg_base.evtlog->last =
sde_dbg_base.evtlog->first + SDE_EVTLOG_ENTRY;
mutex_unlock(&sde_dbg_base.mutex);
return 0;
}
/*
* sde_dbg_reg_base_open - debugfs open handler for reg base
* @inode: debugfs inode
* @file: file handle
*/
static int sde_dbg_reg_base_open(struct inode *inode, struct file *file)
{
char base_name[64] = {0};
struct sde_dbg_reg_base *reg_base = NULL;
if (!inode || !file)
return -EINVAL;
snprintf(base_name, sizeof(base_name), "%s",
file->f_path.dentry->d_iname);
base_name[strlen(file->f_path.dentry->d_iname) - 4] = '\0';
reg_base = _sde_dump_get_blk_addr(base_name);
if (!reg_base) {
pr_err("error: unable to locate base %s\n",
base_name);
return -EINVAL;
}
/* non-seekable */
file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
file->private_data = reg_base;
return 0;
}
/**
* sde_evtlog_dump_read - debugfs read handler for evtlog dump
* @file: file handler
* @buff: user buffer content for debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_evtlog_dump_read(struct file *file, char __user *buff,
size_t count, loff_t *ppos)
{
ssize_t len = 0;
char evtlog_buf[SDE_EVTLOG_BUF_MAX];
if (!buff || !ppos)
return -EINVAL;
mutex_lock(&sde_dbg_base.mutex);
len = sde_evtlog_dump_to_buffer(sde_dbg_base.evtlog,
evtlog_buf, SDE_EVTLOG_BUF_MAX,
!sde_dbg_base.cur_evt_index, true);
sde_dbg_base.cur_evt_index++;
mutex_unlock(&sde_dbg_base.mutex);
if (len < 0 || len > count) {
pr_err("len is more than user buffer size\n");
return 0;
}
if (copy_to_user(buff, evtlog_buf, len))
return -EFAULT;
*ppos += len;
return len;
}
/**
* sde_evtlog_dump_write - debugfs write handler for evtlog dump
* @file: file handler
* @user_buf: user buffer content from debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_evtlog_dump_write(struct file *file,
const char __user *user_buf, size_t count, loff_t *ppos)
{
_sde_dump_array(NULL, 0, sde_dbg_base.panic_on_err, "dump_debugfs",
true, true, true, false);
return count;
}
static const struct file_operations sde_evtlog_fops = {
.open = sde_dbg_debugfs_open,
.read = sde_evtlog_dump_read,
.write = sde_evtlog_dump_write,
};
/**
* sde_dbg_ctrl_read - debugfs read handler for debug ctrl read
* @file: file handler
* @buff: user buffer content for debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_dbg_ctrl_read(struct file *file, char __user *buff,
size_t count, loff_t *ppos)
{
ssize_t len = 0;
char buf[24] = {'\0'};
if (!buff || !ppos)
return -EINVAL;
if (*ppos)
return 0; /* the end */
len = snprintf(buf, sizeof(buf), "0x%x\n", sde_dbg_base.debugfs_ctrl);
pr_debug("%s: ctrl:0x%x len:0x%zx\n",
__func__, sde_dbg_base.debugfs_ctrl, len);
if (len < 0 || len >= sizeof(buf))
return 0;
if ((count < sizeof(buf)) || copy_to_user(buff, buf, len)) {
pr_err("error copying the buffer! count:0x%zx\n", count);
return -EFAULT;
}
*ppos += len; /* increase offset */
return len;
}
/**
* sde_dbg_ctrl_write - debugfs read handler for debug ctrl write
* @file: file handler
* @user_buf: user buffer content from debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_dbg_ctrl_write(struct file *file,
const char __user *user_buf, size_t count, loff_t *ppos)
{
u32 dbg_ctrl = 0;
char buf[24];
if (!file) {
pr_err("DbgDbg: %s: error no file --\n", __func__);
return -EINVAL;
}
if (count >= sizeof(buf))
return -EFAULT;
if (copy_from_user(buf, user_buf, count))
return -EFAULT;
buf[count] = 0; /* end of string */
if (kstrtouint(buf, 0, &dbg_ctrl)) {
pr_err("%s: error in the number of bytes\n", __func__);
return -EFAULT;
}
pr_debug("dbg_ctrl_read:0x%x\n", dbg_ctrl);
sde_dbg_base.debugfs_ctrl = dbg_ctrl;
return count;
}
static const struct file_operations sde_dbg_ctrl_fops = {
.open = sde_dbg_debugfs_open,
.read = sde_dbg_ctrl_read,
.write = sde_dbg_ctrl_write,
};
static int sde_recovery_regdump_open(struct inode *inode, struct file *file)
{
if (!inode || !file)
return -EINVAL;
/* non-seekable */
file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
file->private_data = inode->i_private;
/* initialize to start position */
sde_dbg_base.regbuf.rpos = 0;
sde_dbg_base.regbuf.cur_blk = NULL;
sde_dbg_base.regbuf.dump_done = false;
return 0;
}
static ssize_t _sde_dbg_dump_reg_rows(u32 reg_start,
void *start, int count, char *buf, int buflen)
{
int i;
int len = 0;
u32 *addr;
u32 reg_offset = 0;
int rows = min(count / DUMP_CLMN_COUNT, DUMP_MAX_LINES_PER_BLK);
if (!start || !buf) {
pr_err("invalid address for dump\n");
return len;
}
if (buflen < PAGE_SIZE) {
pr_err("buffer too small for dump\n");
return len;
}
for (i = 0; i < rows; i++) {
addr = start + (i * DUMP_CLMN_COUNT * sizeof(u32));
reg_offset = reg_start + (i * DUMP_CLMN_COUNT * sizeof(u32));
if (buflen < (len + DUMP_LINE_SIZE))
break;
len += snprintf(buf + len, DUMP_LINE_SIZE,
"0x%.8X | %.8X %.8X %.8X %.8X\n",
reg_offset, addr[0], addr[1], addr[2], addr[3]);
}
return len;
}
static int _sde_dbg_recovery_dump_sub_blk(struct sde_dbg_reg_range *sub_blk,
char *buf, int buflen)
{
int count = 0;
int len = 0;
if (!sub_blk || (buflen < PAGE_SIZE)) {
pr_err("invalid params buflen:%d subblk valid:%d\n",
buflen, sub_blk != NULL);
return len;
}
count = (sub_blk->offset.end - sub_blk->offset.start) / (sizeof(u32));
if (count < DUMP_CLMN_COUNT) {
pr_err("invalid count for register dumps :%d\n", count);
return len;
}
len += snprintf(buf + len, DUMP_LINE_SIZE,
"------------------------------------------\n");
len += snprintf(buf + len, DUMP_LINE_SIZE,
"**** sub block [%s] - size:%d ****\n",
sub_blk->range_name, count);
len += _sde_dbg_dump_reg_rows(sub_blk->offset.start, sub_blk->reg_dump,
count, buf + len, buflen - len);
return len;
}
static int _sde_dbg_recovery_dump_reg_blk(struct sde_dbg_reg_base *blk,
char *buf, int buf_size, int *out_len)
{
int ret = 0;
int len = 0;
struct sde_dbg_reg_range *sub_blk;
if (buf_size < PAGE_SIZE) {
pr_err("buffer too small for dump\n");
return len;
}
if (!blk || !strlen(blk->name)) {
len += snprintf(buf + len, DUMP_LINE_SIZE,
"Found one invalid block - skip dump\n");
*out_len = len;
return len;
}
len += snprintf(buf + len, DUMP_LINE_SIZE,
"******************************************\n");
len += snprintf(buf + len, DUMP_LINE_SIZE,
"==========================================\n");
len += snprintf(buf + len, DUMP_LINE_SIZE,
"*********** DUMP of %s block *************\n",
blk->name);
len += snprintf(buf + len, DUMP_LINE_SIZE,
"count:%ld max-off:0x%lx has_sub_blk:%d\n",
blk->cnt, blk->max_offset,
!list_empty(&blk->sub_range_list));
if (list_empty(&blk->sub_range_list)) {
len += _sde_dbg_dump_reg_rows(0, blk->reg_dump,
blk->max_offset / sizeof(u32), buf + len,
buf_size - len);
} else {
list_for_each_entry(sub_blk, &blk->sub_range_list, head)
len += _sde_dbg_recovery_dump_sub_blk(sub_blk,
buf + len, buf_size - len);
}
*out_len = len;
return ret;
}
static ssize_t sde_recovery_regdump_read(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
ssize_t len = 0;
int usize = 0;
struct sde_dbg_base *dbg_base = &sde_dbg_base;
struct sde_dbg_regbuf *rbuf = &dbg_base->regbuf;
mutex_lock(&sde_dbg_base.mutex);
if (!rbuf->dump_done && !rbuf->cur_blk) {
if (!rbuf->buf)
rbuf->buf = kzalloc(DUMP_BUF_SIZE, GFP_KERNEL);
if (!rbuf->buf) {
len = -ENOMEM;
goto err;
}
rbuf->rpos = 0;
rbuf->len = 0;
rbuf->buf_size = DUMP_BUF_SIZE;
rbuf->cur_blk = list_first_entry(&dbg_base->reg_base_list,
struct sde_dbg_reg_base, reg_base_head);
if (rbuf->cur_blk)
_sde_dbg_recovery_dump_reg_blk(rbuf->cur_blk,
rbuf->buf,
rbuf->buf_size,
&rbuf->len);
pr_debug("dumping done for blk:%s len:%d\n", rbuf->cur_blk ?
rbuf->cur_blk->name : "unknown", rbuf->len);
} else if (rbuf->len == rbuf->rpos && rbuf->cur_blk) {
rbuf->rpos = 0;
rbuf->len = 0;
rbuf->buf_size = DUMP_BUF_SIZE;
if (rbuf->cur_blk == list_last_entry(&dbg_base->reg_base_list,
struct sde_dbg_reg_base, reg_base_head))
rbuf->cur_blk = NULL;
else
rbuf->cur_blk = list_next_entry(rbuf->cur_blk,
reg_base_head);
if (rbuf->cur_blk)
_sde_dbg_recovery_dump_reg_blk(rbuf->cur_blk,
rbuf->buf,
rbuf->buf_size,
&rbuf->len);
pr_debug("dumping done for blk:%s len:%d\n", rbuf->cur_blk ?
rbuf->cur_blk->name : "unknown", rbuf->len);
}
if ((rbuf->len - rbuf->rpos) > 0) {
usize = ((rbuf->len - rbuf->rpos) > count) ?
count : rbuf->len - rbuf->rpos;
if (copy_to_user(ubuf, rbuf->buf + rbuf->rpos, usize)) {
len = -EFAULT;
goto err;
}
len = usize;
rbuf->rpos += usize;
*ppos += usize;
}
if (!len && rbuf->buf)
rbuf->dump_done = true;
err:
mutex_unlock(&sde_dbg_base.mutex);
return len;
}
static const struct file_operations sde_recovery_reg_fops = {
.open = sde_recovery_regdump_open,
.read = sde_recovery_regdump_read,
};
static int sde_recovery_dbgbus_dump_open(struct inode *inode, struct file *file)
{
if (!inode || !file)
return -EINVAL;
/* non-seekable */
file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
file->private_data = inode->i_private;
mutex_lock(&sde_dbg_base.mutex);
sde_dbg_base.dbgbus_dump_idx = 0;
mutex_unlock(&sde_dbg_base.mutex);
return 0;
}
static ssize_t sde_recovery_dbgbus_dump_read(struct file *file,
char __user *buff,
size_t count, loff_t *ppos)
{
ssize_t len = 0;
char evtlog_buf[SDE_EVTLOG_BUF_MAX];
u32 *data;
struct sde_dbg_sde_debug_bus *bus;
mutex_lock(&sde_dbg_base.mutex);
bus = &sde_dbg_base.dbgbus_sde;
if (!bus->cmn.dumped_content || !bus->cmn.entries_size)
goto dump_done;
if (sde_dbg_base.dbgbus_dump_idx <=
((bus->cmn.entries_size - 1) * DUMP_CLMN_COUNT)) {
data = &bus->cmn.dumped_content[
sde_dbg_base.dbgbus_dump_idx];
len = snprintf(evtlog_buf, SDE_EVTLOG_BUF_MAX,
"0x%.8X | %.8X %.8X %.8X %.8X\n",
sde_dbg_base.dbgbus_dump_idx,
data[0], data[1], data[2], data[3]);
sde_dbg_base.dbgbus_dump_idx += DUMP_CLMN_COUNT;
if ((count < len) || copy_to_user(buff, evtlog_buf, len)) {
len = -EFAULT;
goto dump_done;
}
*ppos += len;
}
dump_done:
mutex_unlock(&sde_dbg_base.mutex);
return len;
}
static const struct file_operations sde_recovery_dbgbus_fops = {
.open = sde_recovery_dbgbus_dump_open,
.read = sde_recovery_dbgbus_dump_read,
};
static int sde_recovery_vbif_dbgbus_dump_open(struct inode *inode,
struct file *file)
{
if (!inode || !file)
return -EINVAL;
/* non-seekable */
file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
file->private_data = inode->i_private;
mutex_lock(&sde_dbg_base.mutex);
sde_dbg_base.vbif_dbgbus_dump_idx = 0;
mutex_unlock(&sde_dbg_base.mutex);
return 0;
}
static ssize_t sde_recovery_vbif_dbgbus_dump_read(struct file *file,
char __user *buff,
size_t count, loff_t *ppos)
{
ssize_t len = 0;
char evtlog_buf[SDE_EVTLOG_BUF_MAX];
int i;
u32 *data;
u32 list_size = 0;
struct vbif_debug_bus_entry *head;
struct sde_dbg_vbif_debug_bus *bus;
mutex_lock(&sde_dbg_base.mutex);
bus = &sde_dbg_base.dbgbus_vbif_rt;
if (!bus->cmn.dumped_content || !bus->cmn.entries_size)
goto dump_done;
/* calculate total number of test point */
for (i = 0; i < bus->cmn.entries_size; i++) {
head = bus->entries + i;
list_size += (head->block_cnt * head->test_pnt_cnt);
}
/* 4 entries for each test point*/
list_size *= DUMP_CLMN_COUNT;
if (sde_dbg_base.vbif_dbgbus_dump_idx < list_size) {
data = &bus->cmn.dumped_content[
sde_dbg_base.vbif_dbgbus_dump_idx];
len = snprintf(evtlog_buf, SDE_EVTLOG_BUF_MAX,
"0x%.8X | %.8X %.8X %.8X %.8X\n",
sde_dbg_base.vbif_dbgbus_dump_idx,
data[0], data[1], data[2], data[3]);
sde_dbg_base.vbif_dbgbus_dump_idx += DUMP_CLMN_COUNT;
if ((count < len) || copy_to_user(buff, evtlog_buf, len)) {
len = -EFAULT;
goto dump_done;
}
*ppos += len;
}
dump_done:
mutex_unlock(&sde_dbg_base.mutex);
return len;
}
static const struct file_operations sde_recovery_vbif_dbgbus_fops = {
.open = sde_recovery_vbif_dbgbus_dump_open,
.read = sde_recovery_vbif_dbgbus_dump_read,
};
/**
* sde_dbg_reg_base_release - release allocated reg dump file private data
* @inode: debugfs inode
* @file: file handle
* @Return: 0 on success
*/
static int sde_dbg_reg_base_release(struct inode *inode, struct file *file)
{
struct sde_dbg_reg_base *dbg;
if (!file)
return -EINVAL;
dbg = file->private_data;
if (!dbg)
return -ENODEV;
mutex_lock(&sde_dbg_base.mutex);
if (dbg && dbg->buf) {
kfree(dbg->buf);
dbg->buf_len = 0;
dbg->buf = NULL;
}
mutex_unlock(&sde_dbg_base.mutex);
return 0;
}
/**
* sde_dbg_reg_base_is_valid_range - verify if requested memory range is valid
* @off: address offset in bytes
* @cnt: memory size in bytes
* Return: true if valid; false otherwise
*/
static bool sde_dbg_reg_base_is_valid_range(
struct sde_dbg_reg_base *base,
u32 off, u32 cnt)
{
struct sde_dbg_reg_range *node;
pr_debug("check offset=0x%x cnt=0x%x\n", off, cnt);
list_for_each_entry(node, &base->sub_range_list, head) {
pr_debug("%s: start=0x%x end=0x%x\n", node->range_name,
node->offset.start, node->offset.end);
if (node->offset.start <= off
&& off <= node->offset.end
&& off + cnt <= node->offset.end) {
pr_debug("valid range requested\n");
return true;
}
}
pr_err("invalid range requested\n");
return false;
}
/**
* sde_dbg_reg_base_offset_write - set new offset and len to debugfs reg base
* @file: file handler
* @user_buf: user buffer content from debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_dbg_reg_base_offset_write(struct file *file,
const char __user *user_buf, size_t count, loff_t *ppos)
{
struct sde_dbg_reg_base *dbg;
u32 off = 0;
u32 cnt = DEFAULT_BASE_REG_CNT;
char buf[24];
int rc;
if (!file)
return -EINVAL;
dbg = file->private_data;
if (!dbg)
return -ENODEV;
if (count >= sizeof(buf))
return -EFAULT;
if (copy_from_user(buf, user_buf, count))
return -EFAULT;
buf[count] = 0; /* end of string */
if (sscanf(buf, "%5x %x", &off, &cnt) != 2)
return -EFAULT;
if (off > dbg->max_offset)
return -EINVAL;
if (off % sizeof(u32))
return -EINVAL;
if (cnt > (dbg->max_offset - off))
cnt = dbg->max_offset - off;
if (cnt == 0)
return -EINVAL;
if (!list_empty(&dbg->sub_range_list)) {
rc = sde_dbg_reg_base_is_valid_range(dbg, off, cnt);
if (!rc)
return -EINVAL;
}
mutex_lock(&sde_dbg_base.mutex);
dbg->off = off;
dbg->cnt = cnt;
mutex_unlock(&sde_dbg_base.mutex);
pr_debug("offset=%x cnt=%x\n", off, cnt);
return count;
}
/**
* sde_dbg_reg_base_offset_read - read current offset and len of register base
* @file: file handler
* @user_buf: user buffer content from debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_dbg_reg_base_offset_read(struct file *file,
char __user *buff, size_t count, loff_t *ppos)
{
struct sde_dbg_reg_base *dbg;
int len = 0;
char buf[24] = {'\0'};
if (!file)
return -EINVAL;
dbg = file->private_data;
if (!dbg)
return -ENODEV;
if (!ppos)
return -EINVAL;
if (*ppos)
return 0; /* the end */
mutex_lock(&sde_dbg_base.mutex);
if (dbg->off % sizeof(u32)) {
mutex_unlock(&sde_dbg_base.mutex);
return -EFAULT;
}
len = snprintf(buf, sizeof(buf), "0x%08zx %zx\n", dbg->off, dbg->cnt);
if (len < 0 || len >= sizeof(buf)) {
mutex_unlock(&sde_dbg_base.mutex);
return 0;
}
if ((count < sizeof(buf)) || copy_to_user(buff, buf, len)) {
mutex_unlock(&sde_dbg_base.mutex);
return -EFAULT;
}
*ppos += len; /* increase offset */
mutex_unlock(&sde_dbg_base.mutex);
return len;
}
#ifdef CONFIG_DYNAMIC_DEBUG
/**
* sde_dbg_reg_base_reg_write - write to reg base hw at offset a given value
* @file: file handler
* @user_buf: user buffer content from debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_dbg_reg_base_reg_write(struct file *file,
const char __user *user_buf, size_t count, loff_t *ppos)
{
struct sde_dbg_reg_base *dbg;
size_t off;
u32 data, cnt;
char buf[24];
int rc;
if (!file)
return -EINVAL;
dbg = file->private_data;
if (!dbg)
return -ENODEV;
if (count >= sizeof(buf))
return -EFAULT;
if (copy_from_user(buf, user_buf, count))
return -EFAULT;
buf[count] = 0; /* end of string */
cnt = sscanf(buf, "%zx %x", &off, &data);
if (cnt < 2)
return -EFAULT;
if (off % sizeof(u32))
return -EFAULT;
mutex_lock(&sde_dbg_base.mutex);
if (off >= dbg->max_offset) {
mutex_unlock(&sde_dbg_base.mutex);
return -EFAULT;
}
if (!list_empty(&dbg->sub_range_list)) {
rc = sde_dbg_reg_base_is_valid_range(dbg, off, cnt);
if (!rc)
return -EINVAL;
}
rc = pm_runtime_get_sync(sde_dbg_base.dev);
if (rc < 0) {
mutex_unlock(&sde_dbg_base.mutex);
pr_err("failed to enable power %d\n", rc);
return rc;
}
writel_relaxed(data, dbg->base + off);
pm_runtime_put_sync(sde_dbg_base.dev);
mutex_unlock(&sde_dbg_base.mutex);
pr_debug("addr=%zx data=%x\n", off, data);
return count;
}
#endif
/**
* sde_dbg_reg_base_reg_read - read len from reg base hw at current offset
* @file: file handler
* @user_buf: user buffer content from debugfs
* @count: size of user buffer
* @ppos: position offset of user buffer
*/
static ssize_t sde_dbg_reg_base_reg_read(struct file *file,
char __user *user_buf, size_t count, loff_t *ppos)
{
struct sde_dbg_reg_base *dbg;
size_t len;
int rc;
if (!file)
return -EINVAL;
dbg = file->private_data;
if (!dbg) {
pr_err("invalid handle\n");
return -ENODEV;
}
if (!ppos)
return -EINVAL;
mutex_lock(&sde_dbg_base.mutex);
if (!dbg->buf) {
char dump_buf[64];
char *ptr;
int cnt, tot;
dbg->buf_len = sizeof(dump_buf) *
DIV_ROUND_UP(dbg->cnt, ROW_BYTES);
dbg->buf = kzalloc(dbg->buf_len, GFP_KERNEL);
if (!dbg->buf) {
mutex_unlock(&sde_dbg_base.mutex);
return -ENOMEM;
}
if (dbg->off % sizeof(u32)) {
mutex_unlock(&sde_dbg_base.mutex);
return -EFAULT;
}
ptr = dbg->base + dbg->off;
tot = 0;
rc = pm_runtime_get_sync(sde_dbg_base.dev);
if (rc < 0) {
mutex_unlock(&sde_dbg_base.mutex);
pr_err("failed to enable power %d\n", rc);
return rc;
}
for (cnt = dbg->cnt; cnt > 0; cnt -= ROW_BYTES) {
hex_dump_to_buffer(ptr, min(cnt, ROW_BYTES),
ROW_BYTES, GROUP_BYTES, dump_buf,
sizeof(dump_buf), false);
len = scnprintf(dbg->buf + tot, dbg->buf_len - tot,
"0x%08x: %s\n",
((int) (unsigned long) ptr) -
((int) (unsigned long) dbg->base),
dump_buf);
ptr += ROW_BYTES;
tot += len;
if (tot >= dbg->buf_len)
break;
}
pm_runtime_put_sync(sde_dbg_base.dev);
dbg->buf_len = tot;
}
if (*ppos >= dbg->buf_len) {
mutex_unlock(&sde_dbg_base.mutex);
return 0; /* done reading */
}
len = min(count, dbg->buf_len - (size_t) *ppos);
if (copy_to_user(user_buf, dbg->buf + *ppos, len)) {
mutex_unlock(&sde_dbg_base.mutex);
pr_err("failed to copy to user\n");
return -EFAULT;
}
*ppos += len; /* increase offset */
mutex_unlock(&sde_dbg_base.mutex);
return len;
}
static const struct file_operations sde_off_fops = {
.open = sde_dbg_reg_base_open,
.release = sde_dbg_reg_base_release,
.read = sde_dbg_reg_base_offset_read,
.write = sde_dbg_reg_base_offset_write,
};
static const struct file_operations sde_reg_fops = {
.open = sde_dbg_reg_base_open,
.release = sde_dbg_reg_base_release,
.read = sde_dbg_reg_base_reg_read,
#ifdef CONFIG_DYNAMIC_DEBUG
.write = sde_dbg_reg_base_reg_write,
#endif
};
int sde_dbg_debugfs_register(struct dentry *debugfs_root)
{
static struct sde_dbg_base *dbg = &sde_dbg_base;
struct sde_dbg_reg_base *blk_base;
char debug_name[80] = "";
if (!debugfs_root)
return -EINVAL;
debugfs_create_file("dbg_ctrl", 0600, debugfs_root, NULL,
&sde_dbg_ctrl_fops);
debugfs_create_file("dump", 0600, debugfs_root, NULL,
&sde_evtlog_fops);
debugfs_create_u32("enable", 0600, debugfs_root,
&(sde_dbg_base.evtlog->enable));
debugfs_create_u32("panic", 0600, debugfs_root,
&sde_dbg_base.panic_on_err);
debugfs_create_u32("reg_dump", 0600, debugfs_root,
&sde_dbg_base.enable_reg_dump);
debugfs_create_file("recovery_reg", 0400, debugfs_root, NULL,
&sde_recovery_reg_fops);
debugfs_create_file("recovery_dbgbus", 0400, debugfs_root, NULL,
&sde_recovery_dbgbus_fops);
debugfs_create_file("recovery_vbif_dbgbus", 0400, debugfs_root, NULL,
&sde_recovery_vbif_dbgbus_fops);
if (dbg->dbgbus_sde.entries) {
dbg->dbgbus_sde.cmn.name = DBGBUS_NAME_SDE;
snprintf(debug_name, sizeof(debug_name), "%s_dbgbus",
dbg->dbgbus_sde.cmn.name);
dbg->dbgbus_sde.cmn.enable_mask = DEFAULT_DBGBUS_SDE;
debugfs_create_u32(debug_name, 0600, debugfs_root,
&dbg->dbgbus_sde.cmn.enable_mask);
}
if (dbg->dbgbus_vbif_rt.entries) {
dbg->dbgbus_vbif_rt.cmn.name = DBGBUS_NAME_VBIF_RT;
snprintf(debug_name, sizeof(debug_name), "%s_dbgbus",
dbg->dbgbus_vbif_rt.cmn.name);
dbg->dbgbus_vbif_rt.cmn.enable_mask = DEFAULT_DBGBUS_VBIFRT;
debugfs_create_u32(debug_name, 0600, debugfs_root,
&dbg->dbgbus_vbif_rt.cmn.enable_mask);
}
list_for_each_entry(blk_base, &dbg->reg_base_list, reg_base_head) {
snprintf(debug_name, sizeof(debug_name), "%s_off",
blk_base->name);
debugfs_create_file(debug_name, 0600, debugfs_root, blk_base,
&sde_off_fops);
snprintf(debug_name, sizeof(debug_name), "%s_reg",
blk_base->name);
debugfs_create_file(debug_name, 0400, debugfs_root, blk_base,
&sde_reg_fops);
}
return 0;
}
static void _sde_dbg_debugfs_destroy(void)
{
}
void sde_dbg_init_dbg_buses(u32 hwversion)
{
static struct sde_dbg_base *dbg = &sde_dbg_base;
memset(&dbg->dbgbus_sde, 0, sizeof(dbg->dbgbus_sde));
memset(&dbg->dbgbus_vbif_rt, 0, sizeof(dbg->dbgbus_vbif_rt));
if (IS_SM8150_TARGET(hwversion) || IS_SM6150_TARGET(hwversion) ||
IS_SDMMAGPIE_TARGET(hwversion) ||
IS_SDMTRINKET_TARGET(hwversion)) {
dbg->dbgbus_sde.entries = dbg_bus_sde_sm8150;
dbg->dbgbus_sde.cmn.entries_size =
ARRAY_SIZE(dbg_bus_sde_sm8150);
dbg->dbgbus_sde.cmn.flags = DBGBUS_FLAGS_DSPP;
dbg->dbgbus_vbif_rt.entries = vbif_dbg_bus_msm8998;
dbg->dbgbus_vbif_rt.cmn.entries_size =
ARRAY_SIZE(vbif_dbg_bus_msm8998);
dbg->dbgbus_dsi.entries = NULL;
dbg->dbgbus_dsi.size = 0;
} else if (IS_KONA_TARGET(hwversion) || IS_SAIPAN_TARGET(hwversion)) {
dbg->dbgbus_sde.entries = dbg_bus_sde_kona;
dbg->dbgbus_sde.cmn.entries_size =
ARRAY_SIZE(dbg_bus_sde_kona);
dbg->dbgbus_sde.cmn.flags = DBGBUS_FLAGS_DSPP;
dbg->dbgbus_vbif_rt.entries = vbif_dbg_bus_msm8998;
dbg->dbgbus_vbif_rt.cmn.entries_size =
ARRAY_SIZE(vbif_dbg_bus_msm8998);
dbg->dbgbus_dsi.entries = dsi_dbg_bus_kona;
dbg->dbgbus_dsi.size = ARRAY_SIZE(dsi_dbg_bus_kona);
} else {
pr_err("unsupported chipset id %X\n", hwversion);
}
}
int sde_dbg_init(struct device *dev)
{
if (!dev) {
pr_err("invalid params\n");
return -EINVAL;
}
mutex_init(&sde_dbg_base.mutex);
INIT_LIST_HEAD(&sde_dbg_base.reg_base_list);
sde_dbg_base.dev = dev;
sde_dbg_base.evtlog = sde_evtlog_init();
if (IS_ERR_OR_NULL(sde_dbg_base.evtlog))
return PTR_ERR(sde_dbg_base.evtlog);
sde_dbg_base_evtlog = sde_dbg_base.evtlog;
INIT_WORK(&sde_dbg_base.dump_work, _sde_dump_work);
sde_dbg_base.work_panic = false;
sde_dbg_base.panic_on_err = DEFAULT_PANIC;
sde_dbg_base.enable_reg_dump = DEFAULT_REGDUMP;
memset(&sde_dbg_base.regbuf, 0, sizeof(sde_dbg_base.regbuf));
pr_info("evtlog_status: enable:%d, panic:%d, dump:%d\n",
sde_dbg_base.evtlog->enable, sde_dbg_base.panic_on_err,
sde_dbg_base.enable_reg_dump);
return 0;
}
static void sde_dbg_reg_base_destroy(void)
{
struct sde_dbg_reg_range *range_node, *range_tmp;
struct sde_dbg_reg_base *blk_base, *blk_tmp;
struct sde_dbg_base *dbg_base = &sde_dbg_base;
if (!dbg_base)
return;
list_for_each_entry_safe(blk_base, blk_tmp, &dbg_base->reg_base_list,
reg_base_head) {
list_for_each_entry_safe(range_node, range_tmp,
&blk_base->sub_range_list, head) {
list_del(&range_node->head);
kfree(range_node);
}
list_del(&blk_base->reg_base_head);
kfree(blk_base);
}
}
/**
* sde_dbg_destroy - destroy sde debug facilities
*/
void sde_dbg_destroy(void)
{
kfree(sde_dbg_base.regbuf.buf);
memset(&sde_dbg_base.regbuf, 0, sizeof(sde_dbg_base.regbuf));
_sde_dbg_debugfs_destroy();
sde_dbg_base_evtlog = NULL;
sde_evtlog_destroy(sde_dbg_base.evtlog);
sde_dbg_base.evtlog = NULL;
sde_dbg_reg_base_destroy();
mutex_destroy(&sde_dbg_base.mutex);
}
int sde_dbg_reg_register_base(const char *name, void __iomem *base,
size_t max_offset)
{
struct sde_dbg_base *dbg_base = &sde_dbg_base;
struct sde_dbg_reg_base *reg_base;
if (!name || !strlen(name)) {
pr_err("no debug name provided\n");
return -EINVAL;
}
reg_base = kzalloc(sizeof(*reg_base), GFP_KERNEL);
if (!reg_base)
return -ENOMEM;
strlcpy(reg_base->name, name, sizeof(reg_base->name));
reg_base->base = base;
reg_base->max_offset = max_offset;
reg_base->off = 0;
reg_base->cnt = DEFAULT_BASE_REG_CNT;
reg_base->reg_dump = NULL;
/* Initialize list to make sure check for null list will be valid */
INIT_LIST_HEAD(&reg_base->sub_range_list);
pr_debug("%s base: %pK max_offset 0x%zX\n", reg_base->name,
reg_base->base, reg_base->max_offset);
list_add(&reg_base->reg_base_head, &dbg_base->reg_base_list);
return 0;
}
int sde_dbg_reg_register_cb(const char *name, void (*cb)(void *), void *ptr)
{
struct sde_dbg_base *dbg_base = &sde_dbg_base;
struct sde_dbg_reg_base *reg_base;
if (!name || !strlen(name)) {
pr_err("no debug name provided\n");
return -EINVAL;
}
reg_base = kzalloc(sizeof(*reg_base), GFP_KERNEL);
if (!reg_base)
return -ENOMEM;
strlcpy(reg_base->name, name, sizeof(reg_base->name));
reg_base->base = NULL;
reg_base->max_offset = 0;
reg_base->off = 0;
reg_base->cnt = DEFAULT_BASE_REG_CNT;
reg_base->reg_dump = NULL;
reg_base->cb = cb;
reg_base->cb_ptr = ptr;
/* Initialize list to make sure check for null list will be valid */
INIT_LIST_HEAD(&reg_base->sub_range_list);
pr_debug("%s cb: %pK cb_ptr: %pK\n", reg_base->name,
reg_base->cb, reg_base->cb_ptr);
list_add(&reg_base->reg_base_head, &dbg_base->reg_base_list);
return 0;
}
void sde_dbg_reg_unregister_cb(const char *name, void (*cb)(void *), void *ptr)
{
struct sde_dbg_base *dbg_base = &sde_dbg_base;
struct sde_dbg_reg_base *reg_base;
if (!dbg_base)
return;
list_for_each_entry(reg_base, &dbg_base->reg_base_list, reg_base_head) {
if (strlen(reg_base->name) &&
!strcmp(reg_base->name, name)) {
pr_debug("%s cb: %pK cb_ptr: %pK\n", reg_base->name,
reg_base->cb, reg_base->cb_ptr);
list_del(&reg_base->reg_base_head);
kfree(reg_base);
break;
}
}
}
void sde_dbg_reg_register_dump_range(const char *base_name,
const char *range_name, u32 offset_start, u32 offset_end,
uint32_t xin_id)
{
struct sde_dbg_reg_base *reg_base;
struct sde_dbg_reg_range *range;
reg_base = _sde_dump_get_blk_addr(base_name);
if (!reg_base) {
pr_err("error: for range %s unable to locate base %s\n",
range_name, base_name);
return;
}
if (!range_name || strlen(range_name) == 0) {
pr_err("%pS: bad range name, base_name %s, offset_start 0x%X, end 0x%X\n",
__builtin_return_address(0), base_name,
offset_start, offset_end);
return;
}
if (offset_end - offset_start < REG_DUMP_ALIGN ||
offset_start > offset_end) {
pr_err("%pS: bad range, base_name %s, range_name %s, offset_start 0x%X, end 0x%X\n",
__builtin_return_address(0), base_name,
range_name, offset_start, offset_end);
return;
}
range = kzalloc(sizeof(*range), GFP_KERNEL);
if (!range)
return;
strlcpy(range->range_name, range_name, sizeof(range->range_name));
range->offset.start = offset_start;
range->offset.end = offset_end;
range->xin_id = xin_id;
list_add_tail(&range->head, &reg_base->sub_range_list);
pr_debug("base %s, range %s, start 0x%X, end 0x%X\n",
base_name, range->range_name,
range->offset.start, range->offset.end);
}
void sde_dbg_set_sde_top_offset(u32 blk_off)
{
sde_dbg_base.dbgbus_sde.top_blk_off = blk_off;
}
Reference in New Issue View Git Blame Copy Permalink