diff --git a/msm/dp/dp_display.c b/msm/dp/dp_display.c index 22b394442c..7432a0783b 100644 --- a/msm/dp/dp_display.c +++ b/msm/dp/dp_display.c @@ -2118,23 +2118,23 @@ static void dp_display_dbg_reister(struct dp_display_private *dp) io = &parser->get_io(parser, "dp_ahb")->io; if (io) - sde_dbg_reg_register_base("dp_ahb", io->base, io->len); + sde_dbg_reg_register_base("dp_ahb", io->base, io->len, SDE_DBG_DP); io = &parser->get_io(parser, "dp_aux")->io; if (io) - sde_dbg_reg_register_base("dp_aux", io->base, io->len); + sde_dbg_reg_register_base("dp_aux", io->base, io->len, SDE_DBG_DP); io = &parser->get_io(parser, "dp_link")->io; if (io) - sde_dbg_reg_register_base("dp_link", io->base, io->len); + sde_dbg_reg_register_base("dp_link", io->base, io->len, SDE_DBG_DP); io = &parser->get_io(parser, "dp_p0")->io; if (io) - sde_dbg_reg_register_base("dp_p0", io->base, io->len); + sde_dbg_reg_register_base("dp_p0", io->base, io->len, SDE_DBG_DP); io = &parser->get_io(parser, "hdcp_physical")->io; if (io) - sde_dbg_reg_register_base("hdcp_physical", io->base, io->len); + sde_dbg_reg_register_base("hdcp_physical", io->base, io->len, SDE_DBG_DP); } static int dp_display_post_init(struct dp_display *dp_display) diff --git a/msm/dsi/dsi_ctrl.c b/msm/dsi/dsi_ctrl.c index 7552ed9217..06859948ff 100644 --- a/msm/dsi/dsi_ctrl.c +++ b/msm/dsi/dsi_ctrl.c @@ -334,10 +334,9 @@ static int dsi_ctrl_debugfs_init(struct dsi_ctrl *dsi_ctrl, dsi_ctrl->debugfs_root = dir; - snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_ctrl", - dsi_ctrl->cell_index); + snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_ctrl", dsi_ctrl->cell_index); sde_dbg_reg_register_base(dbg_name, dsi_ctrl->hw.base, - msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl")); + msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl"), SDE_DBG_DSI); error_remove_dir: debugfs_remove(dir); error: @@ -355,11 +354,9 @@ static int dsi_ctrl_debugfs_init(struct dsi_ctrl *dsi_ctrl, { char dbg_name[DSI_DEBUG_NAME_LEN]; - snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_ctrl", - dsi_ctrl->cell_index); - sde_dbg_reg_register_base(dbg_name, - dsi_ctrl->hw.base, - msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl")); + snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_ctrl", dsi_ctrl->cell_index); + sde_dbg_reg_register_base(dbg_name, dsi_ctrl->hw.base, + msm_iomap_size(dsi_ctrl->pdev, "dsi_ctrl"), SDE_DBG_DSI); return 0; } static int dsi_ctrl_debugfs_deinit(struct dsi_ctrl *dsi_ctrl) diff --git a/msm/dsi/dsi_phy.c b/msm/dsi/dsi_phy.c index 5d7f84a868..58d35f04f8 100644 --- a/msm/dsi/dsi_phy.c +++ b/msm/dsi/dsi_phy.c @@ -657,7 +657,7 @@ int dsi_phy_drv_init(struct msm_dsi_phy *dsi_phy) snprintf(dbg_name, DSI_DEBUG_NAME_LEN, "dsi%d_phy", dsi_phy->index); sde_dbg_reg_register_base(dbg_name, dsi_phy->hw.base, - msm_iomap_size(dsi_phy->pdev, "dsi_phy")); + msm_iomap_size(dsi_phy->pdev, "dsi_phy"), SDE_DBG_DSI); return 0; } diff --git a/msm/sde/sde_encoder.c b/msm/sde/sde_encoder.c index 01982797ea..45054f552a 100644 --- a/msm/sde/sde_encoder.c +++ b/msm/sde/sde_encoder.c @@ -3608,8 +3608,7 @@ void sde_encoder_helper_hw_reset(struct sde_encoder_phys *phys_enc) if (rc) { SDE_ERROR_ENC(sde_enc, "connector soft reset failure\n"); - SDE_DBG_DUMP("all", "dbg_bus", "vbif_dbg_bus", - "panic"); + SDE_DBG_DUMP(SDE_DBG_BUILT_IN_ALL, "panic"); } } } diff --git a/msm/sde/sde_encoder_phys_cmd.c b/msm/sde/sde_encoder_phys_cmd.c index 03da5734e6..45abb3938d 100644 --- a/msm/sde/sde_encoder_phys_cmd.c +++ b/msm/sde/sde_encoder_phys_cmd.c @@ -544,9 +544,9 @@ static int _sde_encoder_phys_cmd_handle_ppdone_timeout( mutex_lock(phys_enc->vblank_ctl_lock); sde_encoder_helper_unregister_irq(phys_enc, INTR_IDX_RDPTR); if (sde_kms_is_secure_session_inprogress(phys_enc->sde_kms)) - SDE_DBG_DUMP("secure", "all", "dbg_bus"); + SDE_DBG_DUMP(SDE_DBG_BUILT_IN_ALL, "secure"); else - SDE_DBG_DUMP("all", "dbg_bus", "vbif_dbg_bus"); + SDE_DBG_DUMP(SDE_DBG_BUILT_IN_ALL); sde_encoder_helper_register_irq(phys_enc, INTR_IDX_RDPTR); mutex_unlock(phys_enc->vblank_ctl_lock); } @@ -559,7 +559,7 @@ static int _sde_encoder_phys_cmd_handle_ppdone_timeout( sde_connector_event_notify(conn, DRM_EVENT_SDE_HW_RECOVERY, sizeof(uint8_t), SDE_RECOVERY_CAPTURE); else if (cmd_enc->pp_timeout_report_cnt) - SDE_DBG_DUMP("dsi_dbg_bus", "panic"); + SDE_DBG_DUMP(0x0, "panic"); /* request a ctl reset before the next kickoff */ phys_enc->enable_state = SDE_ENC_ERR_NEEDS_HW_RESET; @@ -649,12 +649,9 @@ static int _sde_encoder_phys_cmd_poll_write_pointer_started( ret = hw_pp->ops.poll_timeout_wr_ptr(hw_pp, timeout_us); if (ret) { - SDE_EVT32(DRMID(phys_enc->parent), - phys_enc->hw_pp->idx - PINGPONG_0, - phys_enc->hw_intf->idx - INTF_0, - timeout_us, - ret); - SDE_DBG_DUMP("all", "dbg_bus", "vbif_dbg_bus", "panic"); + SDE_EVT32(DRMID(phys_enc->parent), phys_enc->hw_pp->idx - PINGPONG_0, + phys_enc->hw_intf->idx - INTF_0, timeout_us, ret); + SDE_DBG_DUMP(SDE_DBG_BUILT_IN_ALL, "panic"); } end: @@ -1870,7 +1867,7 @@ static void _sde_encoder_autorefresh_disable_seq2( > AUTOREFRESH_SEQ2_POLL_TIMEOUT) { SDE_ERROR_CMDENC(cmd_enc, "disable autorefresh failed\n"); - SDE_DBG_DUMP("all", "dbg_bus", "vbif_dbg_bus", "panic"); + SDE_DBG_DUMP(SDE_DBG_BUILT_IN_ALL, "panic"); break; } diff --git a/msm/sde/sde_encoder_phys_vid.c b/msm/sde/sde_encoder_phys_vid.c index e0570b207d..913086cc6a 100644 --- a/msm/sde/sde_encoder_phys_vid.c +++ b/msm/sde/sde_encoder_phys_vid.c @@ -971,7 +971,7 @@ static int sde_encoder_phys_vid_prepare_for_kickoff( sde_encoder_helper_unregister_irq( phys_enc, INTR_IDX_VSYNC); - SDE_DBG_DUMP("all", "dbg_bus", "vbif_dbg_bus"); + SDE_DBG_DUMP(SDE_DBG_BUILT_IN_ALL); if (irq_enable) sde_encoder_helper_register_irq( @@ -988,7 +988,7 @@ static int sde_encoder_phys_vid_prepare_for_kickoff( sde_connector_event_notify(conn, DRM_EVENT_SDE_HW_RECOVERY, sizeof(uint8_t), SDE_RECOVERY_CAPTURE); else - SDE_DBG_DUMP("panic"); + SDE_DBG_DUMP(0x0, "panic"); /* request a ctl reset before the next flush */ phys_enc->enable_state = SDE_ENC_ERR_NEEDS_HW_RESET; diff --git a/msm/sde/sde_kms.c b/msm/sde/sde_kms.c index 6d21878ef9..9a405a1d54 100644 --- a/msm/sde/sde_kms.c +++ b/msm/sde/sde_kms.c @@ -4274,66 +4274,51 @@ static int _sde_kms_hw_init_ioremap(struct sde_kms *sde_kms, sde_kms->mmio_len = msm_iomap_size(platformdev, "mdp_phys"); rc = sde_dbg_reg_register_base(SDE_DBG_NAME, sde_kms->mmio, - sde_kms->mmio_len); + sde_kms->mmio_len, SDE_DBG_SDE); if (rc) SDE_ERROR("dbg base register kms failed: %d\n", rc); - sde_kms->vbif[VBIF_RT] = msm_ioremap(platformdev, "vbif_phys", - "vbif_phys"); + sde_kms->vbif[VBIF_RT] = msm_ioremap(platformdev, "vbif_phys", "vbif_phys"); if (IS_ERR(sde_kms->vbif[VBIF_RT])) { rc = PTR_ERR(sde_kms->vbif[VBIF_RT]); SDE_ERROR("vbif register memory map failed: %d\n", rc); sde_kms->vbif[VBIF_RT] = NULL; goto error; } - sde_kms->vbif_len[VBIF_RT] = msm_iomap_size(platformdev, - "vbif_phys"); + sde_kms->vbif_len[VBIF_RT] = msm_iomap_size(platformdev, "vbif_phys"); rc = sde_dbg_reg_register_base("vbif_rt", sde_kms->vbif[VBIF_RT], - sde_kms->vbif_len[VBIF_RT]); + sde_kms->vbif_len[VBIF_RT], SDE_DBG_VBIF_RT); if (rc) SDE_ERROR("dbg base register vbif_rt failed: %d\n", rc); - sde_kms->vbif[VBIF_NRT] = msm_ioremap(platformdev, "vbif_nrt_phys", - "vbif_nrt_phys"); + sde_kms->vbif[VBIF_NRT] = msm_ioremap(platformdev, "vbif_nrt_phys", "vbif_nrt_phys"); if (IS_ERR(sde_kms->vbif[VBIF_NRT])) { sde_kms->vbif[VBIF_NRT] = NULL; SDE_DEBUG("VBIF NRT is not defined"); } else { - sde_kms->vbif_len[VBIF_NRT] = msm_iomap_size(platformdev, - "vbif_nrt_phys"); - rc = sde_dbg_reg_register_base("vbif_nrt", - sde_kms->vbif[VBIF_NRT], - sde_kms->vbif_len[VBIF_NRT]); - if (rc) - SDE_ERROR("dbg base register vbif_nrt failed: %d\n", - rc); + sde_kms->vbif_len[VBIF_NRT] = msm_iomap_size(platformdev, "vbif_nrt_phys"); } - sde_kms->reg_dma = msm_ioremap(platformdev, "regdma_phys", - "regdma_phys"); + sde_kms->reg_dma = msm_ioremap(platformdev, "regdma_phys", "regdma_phys"); if (IS_ERR(sde_kms->reg_dma)) { sde_kms->reg_dma = NULL; SDE_DEBUG("REG_DMA is not defined"); } else { - sde_kms->reg_dma_len = msm_iomap_size(platformdev, - "regdma_phys"); - rc = sde_dbg_reg_register_base("reg_dma", - sde_kms->reg_dma, - sde_kms->reg_dma_len); + sde_kms->reg_dma_len = msm_iomap_size(platformdev, "regdma_phys"); + rc = sde_dbg_reg_register_base("reg_dma", sde_kms->reg_dma, + sde_kms->reg_dma_len, SDE_DBG_LUTDMA); if (rc) - SDE_ERROR("dbg base register reg_dma failed: %d\n", - rc); + SDE_ERROR("dbg base register reg_dma failed: %d\n", rc); } - sde_kms->sid = msm_ioremap(platformdev, "sid_phys", - "sid_phys"); + sde_kms->sid = msm_ioremap(platformdev, "sid_phys", "sid_phys"); if (IS_ERR(sde_kms->sid)) { SDE_DEBUG("sid register is not defined: %d\n", rc); sde_kms->sid = NULL; } else { sde_kms->sid_len = msm_iomap_size(platformdev, "sid_phys"); rc = sde_dbg_reg_register_base("sid", sde_kms->sid, - sde_kms->sid_len); + sde_kms->sid_len, SDE_DBG_SID); if (rc) SDE_ERROR("dbg base register sid failed: %d\n", rc); } diff --git a/msm/sde_dbg.c b/msm/sde_dbg.c index fbd333b013..f254684d59 100644 --- a/msm/sde_dbg.c +++ b/msm/sde_dbg.c @@ -23,12 +23,7 @@ #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_DBGBUS_DSI SDE_DBG_DUMP_IN_MEM -#define DEFAULT_DBGBUS_RSC SDE_DBG_DUMP_IN_MEM -#define DEFAULT_DBGBUS_LUTDMA SDE_DBG_DUMP_IN_MEM -#define DEFAULT_DBGBUS_DP SDE_DBG_DUMP_IN_MEM +#define DEFAULT_DBGBUS_DUMP SDE_DBG_DUMP_IN_MEM #define DEFAULT_BASE_REG_CNT DEFAULT_MDSS_HW_BLOCK_SIZE #define GROUP_BYTES 4 #define ROW_BYTES 16 @@ -164,6 +159,7 @@ struct sde_dbg_reg_range { * @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 + * @blk_id: id indicate the HW block */ struct sde_dbg_reg_base { struct list_head reg_base_head; @@ -178,6 +174,7 @@ struct sde_dbg_reg_base { u32 *reg_dump; void (*cb)(void *ptr); void *cb_ptr; + u64 blk_id; }; struct sde_debug_bus_entry { @@ -198,13 +195,12 @@ struct sde_dbg_dsi_ctrl_list_entry { struct sde_dbg_debug_bus_common { char *name; - u32 enable_mask; - bool include_in_deferred_work; u32 entries_size; u32 limited_entries_size; u32 *dumped_content; u32 content_idx; u32 content_size; + u64 blk_id; }; struct sde_dbg_sde_debug_bus { @@ -246,13 +242,14 @@ struct sde_dbg_regbuf { * @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 + * @enable_dbgbus_dump: whether to dump dbgbus into memory, kernel log, or both * @dbgbus_sde: debug bus structure for the sde * @dbgbus_vbif_rt: debug bus structure for the realtime vbif * @dbgbus_dsi: debug bus structure for the dsi * @dbgbus_rsc: debug bus structure for rscc * @dbgbus_lutdma: debug bus structure for the lutdma hw * @dbgbus_dp: debug bus structure for dp - * @dump_all: dump all entries in register dump + * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped * @dump_secure: dump entries excluding few as it is in secure-session * @regbuf: buffer data to track the register dumping in hw recovery * @cur_evt_index: index used for tracking event logs dump in hw recovery @@ -271,6 +268,7 @@ static struct sde_dbg_base { struct work_struct dump_work; bool work_panic; u32 enable_reg_dump; + u32 enable_dbgbus_dump; struct sde_dbg_sde_debug_bus dbgbus_sde; struct sde_dbg_sde_debug_bus dbgbus_vbif_rt; @@ -278,7 +276,7 @@ static struct sde_dbg_base { struct sde_dbg_sde_debug_bus dbgbus_rsc; struct sde_dbg_sde_debug_bus dbgbus_lutdma; struct sde_dbg_sde_debug_bus dbgbus_dp; - bool dump_all; + u64 dump_blk_mask; bool dump_secure; u32 debugfs_ctrl; @@ -465,7 +463,6 @@ static void _sde_dump_reg(const char *dump_name, u32 reg_dump_flag, u32 *dump_addr = NULL; char *end_addr; int i; - int rc; if (!len_bytes || !dump_mem) return; @@ -489,14 +486,6 @@ static void _sde_dump_reg(const char *dump_name, u32 reg_dump_flag, dump_addr = *dump_mem; SDE_DBG_LOG_DUMP_ADDR(dump_name, dump_addr, len_padded, (unsigned long)(addr - base_addr)); - 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; @@ -517,9 +506,6 @@ static void _sde_dump_reg(const char *dump_name, u32 reg_dump_flag, addr += REG_DUMP_ALIGN; } - - if (_sde_power_check(sde_dbg_base.dump_mode)) - pm_runtime_put_sync(sde_dbg_base.dev); } /** @@ -582,10 +568,8 @@ static bool is_block_exclude(char **modules, char *name) * _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) +static void _sde_dump_reg_by_ranges(struct sde_dbg_reg_base *dbg, u32 reg_dump_flag) { char *addr; size_t len; @@ -604,81 +588,48 @@ static void _sde_dump_reg_by_ranges(struct sde_dbg_reg_base *dbg, /* 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); + 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->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); + 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, "Ranges not found, will dump full registers\n"); SDE_DBG_LOG_DUMP_ADDR("base", dbg->base, dbg->max_offset, 0); 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(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 + * _sde_dump_reg_mask - dump register regions based on mask + * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped * @dump_secure: flag to indicate dumping in secure-session */ -static void _sde_dump_reg_by_blk(const char *blk_name, bool dump_secure) +static void _sde_dump_reg_mask(u64 dump_blk_mask, 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) + if (!dump_blk_mask) return; list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head) { - if (!strlen(blk_base->name)) + if ((!(blk_base->blk_id & dump_blk_mask)) || (!strlen(blk_base->name))) continue; - if (dump_secure && - is_block_exclude((char **)exclude_modules, - blk_base->name)) + 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_reg_by_ranges(blk_base, dbg_base->enable_reg_dump); } } @@ -854,7 +805,7 @@ static bool _is_dbg_bus_limited_valid(struct sde_dbg_sde_debug_bus *bus, static void _sde_dbg_dump_bus_entry(struct sde_dbg_sde_debug_bus *bus, struct sde_debug_bus_entry *entries, u32 bus_size, - void __iomem *mem_base, u32 *dump_addr) + void __iomem *mem_base, u32 *dump_addr, u32 enable_mask) { u32 status = 0; int i, j, k; @@ -864,9 +815,9 @@ static void _sde_dbg_dump_bus_entry(struct sde_dbg_sde_debug_bus *bus, if (!bus->read_tp || !bus->clear_tp) return; - in_mem = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_MEM); - in_log = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_LOG); - in_log_limited = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_LOG_LIMITED); + in_mem = (enable_mask & SDE_DBG_DUMP_IN_MEM); + in_log = (enable_mask & SDE_DBG_DUMP_IN_LOG); + in_log_limited = (enable_mask & SDE_DBG_DUMP_IN_LOG_LIMITED); for (k = 0; k < bus_size; k++) { entry = entries + k; @@ -899,7 +850,7 @@ static void _sde_dbg_dump_bus_entry(struct sde_dbg_sde_debug_bus *bus, } } -static void _sde_dbg_dump_sde_dbg_bus(struct sde_dbg_sde_debug_bus *bus) +static void _sde_dbg_dump_sde_dbg_bus(struct sde_dbg_sde_debug_bus *bus, u32 enable_mask) { bool in_mem; u32 **dump_mem = NULL; @@ -939,7 +890,7 @@ static void _sde_dbg_dump_sde_dbg_bus(struct sde_dbg_sde_debug_bus *bus) snprintf(name, sizeof(name), "%s-debugbus", bus->cmn.name); SDE_DBG_LOG_MARKER(name, SDE_DBG_LOG_START); - in_mem = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_MEM); + in_mem = (enable_mask & SDE_DBG_DUMP_IN_MEM); if (in_mem && (!(*dump_mem))) { *dump_mem = devm_kzalloc(sde_dbg_base.dev, list_size, GFP_KERNEL); bus->cmn.content_size = list_size / sizeof(u32); @@ -947,12 +898,12 @@ static void _sde_dbg_dump_sde_dbg_bus(struct sde_dbg_sde_debug_bus *bus) dump_addr = *dump_mem; SDE_DBG_LOG_DUMP_ADDR(bus->cmn.name, dump_addr, list_size, 0); - _sde_dbg_dump_bus_entry(bus, entries, bus_size, mem_base, dump_addr); + _sde_dbg_dump_bus_entry(bus, entries, bus_size, mem_base, dump_addr, enable_mask); SDE_DBG_LOG_MARKER(name, SDE_DBG_LOG_END); } -static void _sde_dbg_dump_dsi_dbg_bus(struct sde_dbg_sde_debug_bus *bus) +static void _sde_dbg_dump_dsi_dbg_bus(struct sde_dbg_sde_debug_bus *bus, u32 enable_mask) { struct sde_dbg_dsi_ctrl_list_entry *ctl_entry; struct list_head *list; @@ -982,7 +933,7 @@ static void _sde_dbg_dump_dsi_dbg_bus(struct sde_dbg_sde_debug_bus *bus) SDE_DBG_LOG_MARKER(name, SDE_DBG_LOG_START); mutex_lock(&sde_dbg_dsi_mutex); - in_mem = (bus->cmn.enable_mask & SDE_DBG_DUMP_IN_MEM); + in_mem = (enable_mask & SDE_DBG_DUMP_IN_MEM); if (in_mem && (!(*dump_mem))) { *dump_mem = devm_kzalloc(sde_dbg_base.dev, list_size, GFP_KERNEL); bus->cmn.content_size = list_size / sizeof(u32); @@ -992,7 +943,8 @@ static void _sde_dbg_dump_dsi_dbg_bus(struct sde_dbg_sde_debug_bus *bus) list_for_each_entry(ctl_entry, &sde_dbg_dsi_list, list) { SDE_DBG_LOG_DUMP_ADDR(ctl_entry->name, dump_addr, list_size / dsi_count, 0); - _sde_dbg_dump_bus_entry(bus, entries, bus_size, ctl_entry->base, dump_addr); + _sde_dbg_dump_bus_entry(bus, entries, bus_size, ctl_entry->base, + dump_addr, enable_mask); } mutex_unlock(&sde_dbg_dsi_mutex); @@ -1001,42 +953,23 @@ static void _sde_dbg_dump_dsi_dbg_bus(struct sde_dbg_sde_debug_bus *bus) /** * _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_dbgbus_dsi: whether to dump the dsi debug bus - * @dump_dbgbus_dp: whether to dump the dp debug bus - * @dump_all: dump evtlog + regs * @dump_secure: flag to indicate dumping in secure-session + * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped */ -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_dbgbus_dsi, bool dump_dbgbus_dp, bool dump_all, bool dump_secure) +static void _sde_dump_array(bool do_panic, const char *name, bool dump_secure, u64 dump_blk_mask) { - int i, rc; + int rc; ktime_t start, end; + struct sde_dbg_base *dbg_base = &sde_dbg_base; - mutex_lock(&sde_dbg_base.mutex); + mutex_lock(&dbg_base->mutex); - if (dump_all) - sde_evtlog_dump_all(sde_dbg_base.evtlog); + sde_evtlog_dump_all(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 (_sde_power_check(sde_dbg_base.dump_mode)) { - rc = pm_runtime_get_sync(sde_dbg_base.dev); + if (_sde_power_check(dbg_base->dump_mode)) { + rc = pm_runtime_get_sync(dbg_base->dev); if (rc < 0) { pr_err("failed to enable power %d\n", rc); return; @@ -1044,33 +977,43 @@ static void _sde_dump_array(struct sde_dbg_reg_base *blk_arr[], } start = ktime_get(); - if (dump_dbgbus_sde) { - _sde_dbg_dump_sde_dbg_bus(&sde_dbg_base.dbgbus_sde); - _sde_dbg_dump_sde_dbg_bus(&sde_dbg_base.dbgbus_lutdma); - _sde_dbg_dump_sde_dbg_bus(&sde_dbg_base.dbgbus_rsc); - } + _sde_dump_reg_mask(dump_blk_mask, dump_secure); + end = ktime_get(); + dev_info(dbg_base->dev, + "reg-dump logging time start_us:%llu, end_us:%llu , duration_us:%llu\n", + ktime_to_us(start), ktime_to_us(end), ktime_us_delta(end, start)); - if (dump_dbgbus_vbif_rt) - _sde_dbg_dump_sde_dbg_bus(&sde_dbg_base.dbgbus_vbif_rt); + start = ktime_get(); + if (dump_blk_mask & SDE_DBG_SDE_DBGBUS) + _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_sde, dbg_base->enable_dbgbus_dump); - if (dump_dbgbus_dsi) - _sde_dbg_dump_dsi_dbg_bus(&sde_dbg_base.dbgbus_dsi); + if (dump_blk_mask & SDE_DBG_LUTDMA_DBGBUS) + _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_lutdma, dbg_base->enable_dbgbus_dump); - if (dump_dbgbus_dp) - _sde_dbg_dump_sde_dbg_bus(&sde_dbg_base.dbgbus_dp); + if (dump_blk_mask & SDE_DBG_RSC_DBGBUS) + _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_rsc, dbg_base->enable_dbgbus_dump); + + if (dump_blk_mask & SDE_DBG_VBIF_RT_DBGBUS) + _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_vbif_rt, dbg_base->enable_dbgbus_dump); + + if (dump_blk_mask & SDE_DBG_DSI_DBGBUS) + _sde_dbg_dump_dsi_dbg_bus(&dbg_base->dbgbus_dsi, dbg_base->enable_dbgbus_dump); + + if (dump_blk_mask & SDE_DBG_DP_DBGBUS) + _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_dp, dbg_base->enable_dbgbus_dump); end = ktime_get(); - dev_info(sde_dbg_base.dev, + dev_info(dbg_base->dev, "debug-bus logging time start_us:%llu, end_us:%llu , duration_us:%llu\n", - ktime_to_us(start), ktime_to_us(end), ktime_us_delta(end , start)); + ktime_to_us(start), ktime_to_us(end), ktime_us_delta(end, start)); - if (_sde_power_check(sde_dbg_base.dump_mode)) - pm_runtime_put_sync(sde_dbg_base.dev); + if (_sde_power_check(dbg_base->dump_mode)) + pm_runtime_put_sync(dbg_base->dev); - if (do_panic && sde_dbg_base.panic_on_err) + if (do_panic && dbg_base->panic_on_err) panic(name); - mutex_unlock(&sde_dbg_base.mutex); + mutex_unlock(&dbg_base->mutex); } /** @@ -1079,87 +1022,36 @@ static void _sde_dump_array(struct sde_dbg_reg_base *blk_arr[], */ 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.dbgbus_dsi.cmn.include_in_deferred_work, - sde_dbg_base.dbgbus_dp.cmn.include_in_deferred_work, - sde_dbg_base.dump_all, sde_dbg_base.dump_secure); + _sde_dump_array(sde_dbg_base.work_panic, "evtlog_workitem", + sde_dbg_base.dump_secure, sde_dbg_base.dump_blk_mask); } -void sde_dbg_dump(enum sde_dbg_dump_context dump_mode, const char *name, ...) +void sde_dbg_dump(enum sde_dbg_dump_context dump_mode, const char *name, u64 dump_blk_mask, ...) { - int i, index = 0; + int i = 0; bool do_panic = false; - bool dump_dbgbus_sde = false; - bool dump_dbgbus_vbif_rt = false; - bool dump_dbgbus_dsi = false; - bool dump_dbgbus_dp = 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; + char *str = NULL; 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)) + 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*))) { + va_start(args, dump_blk_mask); + while ((str = 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")) - dump_dbgbus_dsi = true; - - if (!strcmp(blk_name, "dp_dbg_bus")) - dump_dbgbus_dp = true; - - if (!strcmp(blk_name, "panic")) + if (!strcmp(str, "panic")) do_panic = true; - - if (!strcmp(blk_name, "secure")) + else if (!strcmp(str, "secure")) dump_secure = true; } va_end(args); @@ -1167,17 +1059,10 @@ void sde_dbg_dump(enum sde_dbg_dump_context dump_mode, const char *name, ...) 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.dbgbus_dsi.cmn.include_in_deferred_work = dump_dbgbus_dsi; - sde_dbg_base.dbgbus_rsc.cmn.include_in_deferred_work = dump_dbgbus_sde; - sde_dbg_base.dbgbus_dp.cmn.include_in_deferred_work = dump_dbgbus_dp; - sde_dbg_base.dump_all = dump_all; + sde_dbg_base.dump_blk_mask = dump_blk_mask; 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_dbgbus_dsi, dump_dbgbus_dp, - dump_all, dump_secure); + _sde_dump_array(do_panic, name, dump_secure, dump_blk_mask); } } @@ -1203,23 +1088,19 @@ void sde_dbg_ctrl(const char *name, ...) break; if (!strcmp(blk_name, "stop_ftrace") && - sde_dbg_base.debugfs_ctrl & - DBG_CTRL_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) { + 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"); + SDE_DBG_DUMP_WQ(SDE_DBG_BUILT_IN_ALL, "panic"); } if (!strcmp(blk_name, "reset_hw_panic") && - sde_dbg_base.debugfs_ctrl & - DBG_CTRL_RESET_HW_PANIC) { + sde_dbg_base.debugfs_ctrl & DBG_CTRL_RESET_HW_PANIC) { pr_debug("reset hw panic\n"); panic("reset_hw"); } @@ -1326,8 +1207,8 @@ static ssize_t sde_evtlog_dump_read(struct file *file, char __user *buff, 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, true, true, false); + _sde_dump_array(sde_dbg_base.panic_on_err, "dump_debugfs", false, + sde_dbg_base.dump_blk_mask); return count; } @@ -2146,106 +2027,61 @@ int sde_dbg_debugfs_register(struct device *dev) struct drm_device *ddev = platform_get_drvdata(pdev); struct msm_drm_private *priv = NULL; - if (!ddev) { + if (!ddev || !ddev->dev_private) { pr_err("Invalid drm device node\n"); return -EINVAL; } - priv = ddev->dev_private; - if (!priv) { - pr_err("Invalid msm drm private node\n"); - return -EINVAL; - } - debugfs_root = debugfs_create_dir("debug", - ddev->primary->debugfs_root); + debugfs_root = debugfs_create_dir("debug", ddev->primary->debugfs_root); if (IS_ERR_OR_NULL(debugfs_root)) { - pr_err("debugfs_root create_dir fail, error %ld\n", - PTR_ERR(debugfs_root)); + pr_err("debugfs_root create_dir fail, error %ld\n", PTR_ERR(debugfs_root)); priv->debug_root = NULL; return -EINVAL; } priv->debug_root = debugfs_root; - 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("dbg_ctrl", 0600, debugfs_root, NULL, &sde_dbg_ctrl_fops); + debugfs_create_file("dump", 0600, debugfs_root, NULL, &sde_evtlog_fops); + debugfs_create_file("recovery_reg", 0400, debugfs_root, NULL, &sde_recovery_reg_fops); - if (dbg->dbgbus_sde.entries) { + 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_u32("dbgbus_dump", 0600, debugfs_root, &sde_dbg_base.enable_dbgbus_dump); + debugfs_create_u64("reg_dump_blk_mask", 0600, debugfs_root, &sde_dbg_base.dump_blk_mask); + + if (dbg->dbgbus_sde.entries) debugfs_create_file("recovery_dbgbus", 0400, debugfs_root, NULL, &sde_recovery_dbgbus_fops); - snprintf(debug_name, sizeof(debug_name), "%s_dbgbus", - dbg->dbgbus_sde.cmn.name); - debugfs_create_u32(debug_name, 0600, debugfs_root, - &dbg->dbgbus_sde.cmn.enable_mask); - } - if (dbg->dbgbus_vbif_rt.entries) { + if (dbg->dbgbus_vbif_rt.entries) debugfs_create_file("recovery_vbif_dbgbus", 0400, debugfs_root, NULL, &sde_recovery_vbif_dbgbus_fops); - snprintf(debug_name, sizeof(debug_name), "%s_dbgbus", - dbg->dbgbus_vbif_rt.cmn.name); - debugfs_create_u32(debug_name, 0600, debugfs_root, - &dbg->dbgbus_vbif_rt.cmn.enable_mask); - } - if (dbg->dbgbus_dsi.entries) { + if (dbg->dbgbus_dsi.entries) debugfs_create_file("recovery_dsi_dbgbus", 0400, debugfs_root, NULL, &sde_recovery_dsi_dbgbus_fops); - snprintf(debug_name, sizeof(debug_name), "%s_dbgbus", - dbg->dbgbus_dsi.cmn.name); - debugfs_create_u32(debug_name, 0600, debugfs_root, - &dbg->dbgbus_dsi.cmn.enable_mask); - } - if (dbg->dbgbus_rsc.entries) { + if (dbg->dbgbus_rsc.entries) debugfs_create_file("recovery_rsc_dbgbus", 0400, debugfs_root, NULL, &sde_recovery_rsc_dbgbus_fops); - snprintf(debug_name, sizeof(debug_name), "%s_dbgbus", - dbg->dbgbus_rsc.cmn.name); - debugfs_create_u32(debug_name, 0600, debugfs_root, - &dbg->dbgbus_rsc.cmn.enable_mask); - } - if (dbg->dbgbus_lutdma.entries) { - debugfs_create_file("recovery_lutdma_dbgbus", 0400, - debugfs_root, NULL, - &sde_recovery_lutdma_dbgbus_fops); - snprintf(debug_name, sizeof(debug_name), "%s_dbgbus", - dbg->dbgbus_lutdma.cmn.name); - debugfs_create_u32(debug_name, 0600, debugfs_root, - &dbg->dbgbus_lutdma.cmn.enable_mask); - } + if (dbg->dbgbus_lutdma.entries) + debugfs_create_file("recovery_lutdma_dbgbus", 0400, debugfs_root, + NULL, &sde_recovery_lutdma_dbgbus_fops); - if (dbg->dbgbus_dp.entries) { + if (dbg->dbgbus_dp.entries) debugfs_create_file("recovery_dp_dbgbus", 0400, debugfs_root, NULL, &sde_recovery_dp_dbgbus_fops); - snprintf(debug_name, sizeof(debug_name), "%s_dbgbus", - dbg->dbgbus_dp.cmn.name); - debugfs_create_u32(debug_name, 0600, debugfs_root, - &dbg->dbgbus_dp.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_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); + 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; @@ -2279,7 +2115,7 @@ void sde_dbg_init_dbg_buses(u32 hwversion) dbg->dbgbus_sde.limited_entries = dbg_bus_sde_limited; dbg->dbgbus_sde.cmn.limited_entries_size = ARRAY_SIZE(dbg_bus_sde_limited); dbg->dbgbus_sde.cmn.name = DBGBUS_NAME_SDE; - dbg->dbgbus_sde.cmn.enable_mask = DEFAULT_DBGBUS_SDE; + dbg->dbgbus_sde.cmn.blk_id = SDE_DBG_SDE_DBGBUS; dbg->dbgbus_sde.read_tp = _sde_dbg_sde_read_test_point; dbg->dbgbus_sde.clear_tp = _sde_dbg_sde_clear_test_point; @@ -2288,7 +2124,7 @@ void sde_dbg_init_dbg_buses(u32 hwversion) dbg->dbgbus_vbif_rt.limited_entries = vbif_dbg_bus_limited; dbg->dbgbus_vbif_rt.cmn.limited_entries_size = ARRAY_SIZE(vbif_dbg_bus_limited); dbg->dbgbus_vbif_rt.cmn.name = DBGBUS_NAME_VBIF_RT; - dbg->dbgbus_vbif_rt.cmn.enable_mask = DEFAULT_DBGBUS_VBIFRT; + dbg->dbgbus_vbif_rt.cmn.blk_id = SDE_DBG_VBIF_RT_DBGBUS; dbg->dbgbus_vbif_rt.read_tp = _sde_dbg_vbif_read_test_point; dbg->dbgbus_vbif_rt.clear_tp = _sde_dbg_vbif_clear_test_point; dbg->dbgbus_vbif_rt.disable_block = _sde_dbg_vbif_disable_block; @@ -2296,33 +2132,30 @@ void sde_dbg_init_dbg_buses(u32 hwversion) dbg->dbgbus_dsi.entries = dsi_dbg_bus; dbg->dbgbus_dsi.cmn.entries_size = ARRAY_SIZE(dsi_dbg_bus); dbg->dbgbus_dsi.cmn.name = DBGBUS_NAME_DSI; - dbg->dbgbus_dsi.cmn.enable_mask = DEFAULT_DBGBUS_DSI; + dbg->dbgbus_dsi.cmn.blk_id = SDE_DBG_DSI_DBGBUS; dbg->dbgbus_dsi.read_tp = _sde_dbg_dsi_read_test_point; dbg->dbgbus_dsi.clear_tp = _sde_dbg_cmn_clear_test_point; dbg->dbgbus_rsc.entries = rsc_dbg_bus; dbg->dbgbus_rsc.cmn.entries_size = ARRAY_SIZE(rsc_dbg_bus); dbg->dbgbus_rsc.cmn.name = DBGBUS_NAME_RSC; - dbg->dbgbus_rsc.cmn.enable_mask = DEFAULT_DBGBUS_RSC; + dbg->dbgbus_rsc.cmn.blk_id = SDE_DBG_RSC_DBGBUS; dbg->dbgbus_rsc.read_tp = _sde_dbg_rsc_read_test_point; dbg->dbgbus_rsc.clear_tp = _sde_dbg_cmn_clear_test_point; dbg->dbgbus_dp.entries = dp_dbg_bus; dbg->dbgbus_dp.cmn.entries_size = ARRAY_SIZE(dp_dbg_bus); dbg->dbgbus_dp.cmn.name = DBGBUS_NAME_DP; - dbg->dbgbus_dp.cmn.enable_mask = DEFAULT_DBGBUS_DP; + dbg->dbgbus_dp.cmn.blk_id = SDE_DBG_DP_DBGBUS; dbg->dbgbus_dp.read_tp = _sde_dbg_dp_read_test_point; dbg->dbgbus_dp.clear_tp = _sde_dbg_cmn_clear_test_point; - if (SDE_HW_REV_MAJOR(hwversion) >= 0x7) { - dbg->dbgbus_lutdma.entries = dbg_bus_lutdma; - dbg->dbgbus_lutdma.cmn.name = DBGBUS_NAME_LUTDMA; - dbg->dbgbus_lutdma.cmn.entries_size = ARRAY_SIZE(dbg_bus_lutdma); - dbg->dbgbus_lutdma.cmn.enable_mask = DEFAULT_DBGBUS_LUTDMA; - dbg->dbgbus_lutdma.cmn.include_in_deferred_work = true; - dbg->dbgbus_lutdma.read_tp = _sde_dbg_lutdma_read_test_point; - dbg->dbgbus_lutdma.clear_tp = _sde_dbg_cmn_clear_test_point; - } + dbg->dbgbus_lutdma.entries = dbg_bus_lutdma; + dbg->dbgbus_lutdma.cmn.name = DBGBUS_NAME_LUTDMA; + dbg->dbgbus_lutdma.cmn.blk_id = SDE_DBG_LUTDMA_DBGBUS; + dbg->dbgbus_lutdma.cmn.entries_size = ARRAY_SIZE(dbg_bus_lutdma); + dbg->dbgbus_lutdma.read_tp = _sde_dbg_lutdma_read_test_point; + dbg->dbgbus_lutdma.clear_tp = _sde_dbg_cmn_clear_test_point; } int sde_dbg_init(struct device *dev) @@ -2346,6 +2179,8 @@ int sde_dbg_init(struct device *dev) sde_dbg_base.work_panic = false; sde_dbg_base.panic_on_err = DEFAULT_PANIC; sde_dbg_base.enable_reg_dump = DEFAULT_REGDUMP; + sde_dbg_base.enable_dbgbus_dump = DEFAULT_DBGBUS_DUMP; + sde_dbg_base.dump_blk_mask = SDE_DBG_BUILT_IN_ALL; memset(&sde_dbg_base.regbuf, 0, sizeof(sde_dbg_base.regbuf)); pr_info("evtlog_status: enable:%d, panic:%d, dump:%d\n", @@ -2422,8 +2257,7 @@ int sde_dbg_dsi_ctrl_register(void __iomem *base, const char *name) return 0; } -int sde_dbg_reg_register_base(const char *name, void __iomem *base, - size_t max_offset) +int sde_dbg_reg_register_base(const char *name, void __iomem *base, size_t max_offset, u64 blk_id) { struct sde_dbg_base *dbg_base = &sde_dbg_base; struct sde_dbg_reg_base *reg_base; @@ -2443,6 +2277,7 @@ int sde_dbg_reg_register_base(const char *name, void __iomem *base, reg_base->off = 0; reg_base->cnt = DEFAULT_BASE_REG_CNT; reg_base->reg_dump = NULL; + reg_base->blk_id = blk_id; /* Initialize list to make sure check for null list will be valid */ INIT_LIST_HEAD(®_base->sub_range_list); diff --git a/msm/sde_dbg.h b/msm/sde_dbg.h index 87e1fc0f14..2b5c44ca23 100644 --- a/msm/sde_dbg.h +++ b/msm/sde_dbg.h @@ -28,6 +28,28 @@ #define SDE_EVTLOG_FATAL 0xbad #define SDE_EVTLOG_ERROR 0xebad +/* flags to enable the HW block dumping */ +#define SDE_DBG_SDE BIT(0) +#define SDE_DBG_RSC BIT(1) +#define SDE_DBG_SID BIT(2) +#define SDE_DBG_LUTDMA BIT(3) +#define SDE_DBG_VBIF_RT BIT(4) +#define SDE_DBG_DSI BIT(5) + +/* flags to enable the HW block debugbus dumping */ +#define SDE_DBG_SDE_DBGBUS BIT(12) +#define SDE_DBG_RSC_DBGBUS BIT(13) +#define SDE_DBG_LUTDMA_DBGBUS BIT(14) +#define SDE_DBG_VBIF_RT_DBGBUS BIT(15) +#define SDE_DBG_DSI_DBGBUS BIT(16) + +/* mask to enable all the built-in register blocks */ +#define SDE_DBG_BUILT_IN_ALL 0xffffff + +/* keeping DP separate as DP specific clks needs to be enabled for accessing */ +#define SDE_DBG_DP BIT(24) +#define SDE_DBG_DP_DBGBUS BIT(25) + #define SDE_DBG_DUMP_DATA_LIMITER (NULL) enum sde_dbg_evtlog_flag { @@ -138,36 +160,39 @@ extern struct sde_dbg_evtlog *sde_dbg_base_evtlog; /** * SDE_DBG_DUMP - trigger dumping of all sde_dbg facilities + * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped * @va_args: list of named register dump ranges and regions to dump, as * registered previously through sde_dbg_reg_register_base and * sde_dbg_reg_register_dump_range. * Including the special name "panic" will trigger a panic after * the dumping work has completed. */ -#define SDE_DBG_DUMP(...) sde_dbg_dump(SDE_DBG_DUMP_PROC_CTX, __func__, \ - ##__VA_ARGS__, SDE_DBG_DUMP_DATA_LIMITER) +#define SDE_DBG_DUMP(dump_blk_mask, ...) sde_dbg_dump(SDE_DBG_DUMP_PROC_CTX, __func__, \ + dump_blk_mask, ##__VA_ARGS__, SDE_DBG_DUMP_DATA_LIMITER) /** * SDE_DBG_DUMP_WQ - trigger dumping of all sde_dbg facilities, queuing the work + * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped * @va_args: list of named register dump ranges and regions to dump, as * registered previously through sde_dbg_reg_register_base and * sde_dbg_reg_register_dump_range. * Including the special name "panic" will trigger a panic after * the dumping work has completed. */ -#define SDE_DBG_DUMP_WQ(...) sde_dbg_dump(SDE_DBG_DUMP_IRQ_CTX, __func__, \ - ##__VA_ARGS__, SDE_DBG_DUMP_DATA_LIMITER) +#define SDE_DBG_DUMP_WQ(dump_blk_mask, ...) sde_dbg_dump(SDE_DBG_DUMP_IRQ_CTX, __func__, \ + dump_blk_mask, ##__VA_ARGS__, SDE_DBG_DUMP_DATA_LIMITER) /** * SDE_DBG_DUMP_CLK_EN - trigger dumping of all sde_dbg facilities, without clk + * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped * @va_args: list of named register dump ranges and regions to dump, as * registered previously through sde_dbg_reg_register_base and * sde_dbg_reg_register_dump_range. * Including the special name "panic" will trigger a panic after * the dumping work has completed. */ -#define SDE_DBG_DUMP_CLK_EN(...) sde_dbg_dump(SDE_DBG_DUMP_CLK_ENABLED_CTX, \ - __func__, ##__VA_ARGS__, SDE_DBG_DUMP_DATA_LIMITER) +#define SDE_DBG_DUMP_CLK_EN(dump_blk_mask, ...) sde_dbg_dump(SDE_DBG_DUMP_CLK_ENABLED_CTX, \ + __func__, dump_blk_mask, ##__VA_ARGS__, SDE_DBG_DUMP_DATA_LIMITER) /** * SDE_DBG_EVT_CTRL - trigger a different driver events @@ -261,6 +286,7 @@ void sde_dbg_destroy(void); * sde_dbg_dump - trigger dumping of all sde_dbg facilities * @queue_work: whether to queue the dumping work to the work_struct * @name: string indicating origin of dump + * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped * @va_args: list of named register dump ranges and regions to dump, as * registered previously through sde_dbg_reg_register_base and * sde_dbg_reg_register_dump_range. @@ -268,7 +294,7 @@ void sde_dbg_destroy(void); * the dumping work has completed. * Returns: none */ -void sde_dbg_dump(enum sde_dbg_dump_context mode, const char *name, ...); +void sde_dbg_dump(enum sde_dbg_dump_context mode, const char *name, u64 dump_blk_mask, ...); /** * sde_dbg_ctrl - trigger specific actions for the driver with debugging @@ -286,10 +312,11 @@ void sde_dbg_ctrl(const char *name, ...); * @name: name of base region * @base: base pointer of region * @max_offset: length of region + * @blk_id: hw block id * Returns: 0 or -ERROR */ int sde_dbg_reg_register_base(const char *name, void __iomem *base, - size_t max_offset); + size_t max_offset, u64 blk_id); /** * sde_dbg_reg_register_cb - register a hw register callback for later diff --git a/msm/sde_rsc.c b/msm/sde_rsc.c index 55c97a4d11..5994a15eb1 100644 --- a/msm/sde_rsc.c +++ b/msm/sde_rsc.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2016-2020, The Linux Foundation. All rights reserved. + * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved. */ #define pr_fmt(fmt) "[sde_rsc:%s:%d]: " fmt, __func__, __LINE__ @@ -1626,9 +1626,9 @@ static int sde_rsc_bind(struct device *dev, } sde_dbg_reg_register_base(SDE_RSC_DRV_DBG_NAME, rsc->drv_io.base, - rsc->drv_io.len); - sde_dbg_reg_register_base(SDE_RSC_WRAPPER_DBG_NAME, - rsc->wrapper_io.base, rsc->wrapper_io.len); + rsc->drv_io.len, SDE_DBG_RSC); + sde_dbg_reg_register_base(SDE_RSC_WRAPPER_DBG_NAME, rsc->wrapper_io.base, + rsc->wrapper_io.len, SDE_DBG_RSC); return 0; }