| Message ID | 20230622-devcoredump_patch-v1-6-3b2cdcc6a576@quicinc.com (mailing list archive) |
|---|---|
| State | Not Applicable |
| Headers | show |
| Series | Add support to print sub block registers in dpu hw catalog | expand |
On 23/06/2023 02:48, Ryan McCann wrote: > Currently, the device core dump mechanism does not dump registers of sub > blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper > function to dump hardware blocks that contain sub blocks. > > Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> > --- > drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 +++++++++++++++++++++++++++----- > 1 file changed, 168 insertions(+), 26 deletions(-) > > diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c > index aa8499de1b9f..9b1b1c382269 100644 > --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c > +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c > @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms *kms) > return 0; > } > > +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state *disp_state, > + void __iomem *mmio, void *blk, > + enum dpu_hw_blk_type blk_type) No. Such multiplexers add no value to the code. Please inline it. Not to mention that this patch is hard to review. You both move existing code and add new features. If it were to go, it should have been split into two patches: one introducing the multiplexer and another one adding subblocks. > +{ > + u32 base; > + > + switch (blk_type) { > + case DPU_HW_BLK_TOP: > + { > + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; > + > + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { > + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, > + mmio + top->base, "top"); > + msm_disp_snapshot_add_block(disp_state, top->len - MDP_PERIPH_TOP0_END, > + mmio + top->base + MDP_PERIPH_TOP0_END, > + "top_2"); > + } else { > + msm_disp_snapshot_add_block(disp_state, top->len, mmio + top->base, "top"); > + } > + break; > + } > + case DPU_HW_BLK_LM: > + { > + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; > + > + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + mixer->base, "%s", > + mixer->name); > + break; > + } > + case DPU_HW_BLK_CTL: > + { > + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; > + > + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + ctl->base, "%s", > + ctl->name); > + break; > + } > + case DPU_HW_BLK_INTF: > + { > + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; > + > + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + intf->base, "%s", > + intf->name); > + break; > + } > + case DPU_HW_BLK_WB: > + { > + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; > + > + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + wb->base, "%s", > + wb->name); > + break; > + } > + case DPU_HW_BLK_SSPP: > + { > + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; > + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; > + > + base = sspp_block->base; > + > + msm_disp_snapshot_add_block(disp_state, sspp_block->len, mmio + base, "%s", > + sspp_block->name); > + > + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || > + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || > + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) > + msm_disp_snapshot_add_block(disp_state, sblk->scaler_blk.len, > + mmio + base + sblk->scaler_blk.base, "%s_%s", > + sspp_block->name, sblk->scaler_blk.name); Actually, it would be better to: - drop name from all sblk instances (and use known string instead of the sblk name here) - Use sblk->foo_blk.len to check if it should be printed or not. > + > + if (sspp_block->features & BIT(DPU_SSPP_CSC) || sspp_block->features > + & BIT(DPU_SSPP_CSC_10BIT)) A very bad use of indentation. In future please split logically rather than just filling the line up to the line width. > + msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, > + mmio + base + sblk->csc_blk.base, "%s_%s", > + sspp_block->name, sblk->csc_blk.name); > + break; > + } > + case DPU_HW_BLK_DSPP: > + { > + struct dpu_dspp_cfg *dspp_block = (struct dpu_dspp_cfg *)blk; > + > + base = dspp_block->base; > + > + msm_disp_snapshot_add_block(disp_state, dspp_block->len, mmio + base, "%s", > + dspp_block->name); > + > + if (dspp_block->features & BIT(DPU_DSPP_PCC)) > + msm_disp_snapshot_add_block(disp_state, dspp_block->sblk->pcc.len, > + mmio + base + dspp_block->sblk->pcc.base, > + "%s_%s", dspp_block->name, > + dspp_block->sblk->pcc.name); > + break; > + } > + case DPU_HW_BLK_PINGPONG: > + { > + struct dpu_pingpong_cfg *pingpong_block = (struct dpu_pingpong_cfg *)blk; > + const struct dpu_pingpong_sub_blks *sblk = pingpong_block->sblk; > + > + base = pingpong_block->base; > + > + msm_disp_snapshot_add_block(disp_state, pingpong_block->len, mmio + base, "%s", > + pingpong_block->name); > + > + if (pingpong_block->features & BIT(DPU_PINGPONG_TE2)) > + msm_disp_snapshot_add_block(disp_state, sblk->te2.len, > + mmio + base + sblk->te2.base, "%s_%s", > + pingpong_block->name, sblk->te2.name); > + > + if (pingpong_block->features & BIT(DPU_PINGPONG_DITHER)) > + msm_disp_snapshot_add_block(disp_state, sblk->dither.len, > + mmio + base + sblk->dither.base, "%s_%s", > + pingpong_block->name, sblk->dither.name); > + break; > + } > + case DPU_HW_BLK_DSC: > + { > + struct dpu_dsc_cfg *dsc_block = (struct dpu_dsc_cfg *)blk; > + > + base = dsc_block->base; > + > + if (dsc_block->features & BIT(DPU_DSC_HW_REV_1_2)) { > + struct dpu_dsc_blk enc = dsc_block->sblk->enc; > + struct dpu_dsc_blk ctl = dsc_block->sblk->ctl; > + > + /* For now, pass in a length of 0 because the DSC_BLK register space > + * overlaps with the sblks' register space. > + * > + * TODO: Pass in a length of 0 t0 DSC_BLK_1_2 in the HW catalog where > + * applicable. Nice catch, thank you. We should fix that. > + */ > + msm_disp_snapshot_add_block(disp_state, 0, mmio + base, "%s", > + dsc_block->name); > + msm_disp_snapshot_add_block(disp_state, enc.len, mmio + base + enc.base, > + "%s_%s", dsc_block->name, enc.name); > + msm_disp_snapshot_add_block(disp_state, ctl.len, mmio + base + ctl.base, > + "%s_%s", dsc_block->name, ctl.name); > + } else { > + msm_disp_snapshot_add_block(disp_state, dsc_block->len, mmio + base, "%s", > + dsc_block->name); > + } > + break; > + } > + default: > + DPU_ERROR("Block type not supported."); > + } > +} > + > static void dpu_kms_mdp_snapshot(struct msm_disp_state *disp_state, struct msm_kms *kms) > { > int i; > @@ -899,53 +1047,47 @@ static void dpu_kms_mdp_snapshot(struct msm_disp_state *disp_state, struct msm_k > > /* dump CTL sub-blocks HW regs info */ > for (i = 0; i < cat->ctl_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->ctl[i].len, > - dpu_kms->mmio + cat->ctl[i].base, "ctl_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->ctl[i], > + DPU_HW_BLK_CTL); > > /* dump DSPP sub-blocks HW regs info */ > for (i = 0; i < cat->dspp_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->dspp[i].len, > - dpu_kms->mmio + cat->dspp[i].base, "dspp_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->dspp[i], > + DPU_HW_BLK_DSPP); > > /* dump INTF sub-blocks HW regs info */ > for (i = 0; i < cat->intf_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->intf[i].len, > - dpu_kms->mmio + cat->intf[i].base, "intf_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->intf[i], > + DPU_HW_BLK_INTF); > > /* dump PP sub-blocks HW regs info */ > for (i = 0; i < cat->pingpong_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->pingpong[i].len, > - dpu_kms->mmio + cat->pingpong[i].base, "pingpong_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->pingpong[i], > + DPU_HW_BLK_PINGPONG); > > /* dump SSPP sub-blocks HW regs info */ > for (i = 0; i < cat->sspp_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->sspp[i].len, > - dpu_kms->mmio + cat->sspp[i].base, "sspp_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->sspp[i], > + DPU_HW_BLK_SSPP); > > /* dump LM sub-blocks HW regs info */ > for (i = 0; i < cat->mixer_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->mixer[i].len, > - dpu_kms->mmio + cat->mixer[i].base, "lm_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->mixer[i], > + DPU_HW_BLK_LM); > > /* dump WB sub-blocks HW regs info */ > for (i = 0; i < cat->wb_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->wb[i].len, > - dpu_kms->mmio + cat->wb[i].base, "wb_%d", i); > - > - if (cat->mdp[0].features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { > - msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, > - dpu_kms->mmio + cat->mdp[0].base, "top"); > - msm_disp_snapshot_add_block(disp_state, cat->mdp[0].len - MDP_PERIPH_TOP0_END, > - dpu_kms->mmio + cat->mdp[0].base + MDP_PERIPH_TOP0_END, "top_2"); > - } else { > - msm_disp_snapshot_add_block(disp_state, cat->mdp[0].len, > - dpu_kms->mmio + cat->mdp[0].base, "top"); > - } > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->wb[i], > + DPU_HW_BLK_WB); > + > + /* dump top block */ > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->mdp[0], > + DPU_HW_BLK_TOP); > > /* dump DSC sub-blocks HW regs info */ > for (i = 0; i < cat->dsc_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->dsc[i].len, > - dpu_kms->mmio + cat->dsc[i].base, "dsc_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->dsc[i], > + DPU_HW_BLK_DSC); > > pm_runtime_put_sync(&dpu_kms->pdev->dev); > } >
On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: > On 23/06/2023 02:48, Ryan McCann wrote: >> Currently, the device core dump mechanism does not dump registers of sub >> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >> function to dump hardware blocks that contain sub blocks. >> >> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >> --- >> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >> +++++++++++++++++++++++++++----- >> 1 file changed, 168 insertions(+), 26 deletions(-) >> >> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >> index aa8499de1b9f..9b1b1c382269 100644 >> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms *kms) >> return 0; >> } >> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >> *disp_state, >> + void __iomem *mmio, void *blk, >> + enum dpu_hw_blk_type blk_type) > > No. Such multiplexers add no value to the code. Please inline it. > > Not to mention that this patch is hard to review. You both move existing > code and add new features. If it were to go, it should have been split > into two patches: one introducing the multiplexer and another one adding > subblocks. > Ok. we can split this into: 1) adding the multiplexer 2) adding sub-blk parsing support inside the multiplexer >> +{ >> + u32 base; >> + >> + switch (blk_type) { >> + case DPU_HW_BLK_TOP: >> + { >> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >> + >> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >> + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, >> + mmio + top->base, "top"); >> + msm_disp_snapshot_add_block(disp_state, top->len - >> MDP_PERIPH_TOP0_END, >> + mmio + top->base + MDP_PERIPH_TOP0_END, >> + "top_2"); >> + } else { >> + msm_disp_snapshot_add_block(disp_state, top->len, mmio + >> top->base, "top"); >> + } >> + break; >> + } >> + case DPU_HW_BLK_LM: >> + { >> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >> + >> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + >> mixer->base, "%s", >> + mixer->name); >> + break; >> + } >> + case DPU_HW_BLK_CTL: >> + { >> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >> + >> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >> ctl->base, "%s", >> + ctl->name); >> + break; >> + } >> + case DPU_HW_BLK_INTF: >> + { >> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >> + >> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + >> intf->base, "%s", >> + intf->name); >> + break; >> + } >> + case DPU_HW_BLK_WB: >> + { >> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >> + >> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >> wb->base, "%s", >> + wb->name); >> + break; >> + } >> + case DPU_HW_BLK_SSPP: >> + { >> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; >> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >> + >> + base = sspp_block->base; >> + >> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, mmio >> + base, "%s", >> + sspp_block->name); >> + >> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || >> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >> + msm_disp_snapshot_add_block(disp_state, >> sblk->scaler_blk.len, >> + mmio + base + sblk->scaler_blk.base, >> "%s_%s", >> + sspp_block->name, sblk->scaler_blk.name); > > Actually, it would be better to: > - drop name from all sblk instances (and use known string instead of the > sblk name here) > - Use sblk->foo_blk.len to check if it should be printed or not. > No, I dont agree. If we drop the names from the sub_blk in the catalog, we will end up using "sub_blk_name" string here in the code to indicate which blk that is in the dump. If we add more sub_blks in the catalog in the future we need to keep changing the code over here. Thats not how it should be. Leaving the names in the catalog ensures that this code wont change and only catalog changes when we add a new sub_blk either for an existing or new chipset. catalog is indicating the new blk, and dumping code just prints it. with your approach, dumping code will or can keep changing with chipsets or sub_blks. Thats not how it should be. >> + >> + if (sspp_block->features & BIT(DPU_SSPP_CSC) || >> sspp_block->features >> + & BIT(DPU_SSPP_CSC_10BIT)) > > A very bad use of indentation. In future please split logically rather > than just filling the line up to the line width. > >> + msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, >> + mmio + base + sblk->csc_blk.base, "%s_%s", >> + sspp_block->name, sblk->csc_blk.name); >> + break; >> + } >> + case DPU_HW_BLK_DSPP: >> + { >> + struct dpu_dspp_cfg *dspp_block = (struct dpu_dspp_cfg *)blk; >> + >> + base = dspp_block->base; >> + >> + msm_disp_snapshot_add_block(disp_state, dspp_block->len, mmio >> + base, "%s", >> + dspp_block->name); >> + >> + if (dspp_block->features & BIT(DPU_DSPP_PCC)) >> + msm_disp_snapshot_add_block(disp_state, >> dspp_block->sblk->pcc.len, >> + mmio + base + dspp_block->sblk->pcc.base, >> + "%s_%s", dspp_block->name, >> + dspp_block->sblk->pcc.name); >> + break; >> + } >> + case DPU_HW_BLK_PINGPONG: >> + { >> + struct dpu_pingpong_cfg *pingpong_block = (struct >> dpu_pingpong_cfg *)blk; >> + const struct dpu_pingpong_sub_blks *sblk = pingpong_block->sblk; >> + >> + base = pingpong_block->base; >> + >> + msm_disp_snapshot_add_block(disp_state, pingpong_block->len, >> mmio + base, "%s", >> + pingpong_block->name); >> + >> + if (pingpong_block->features & BIT(DPU_PINGPONG_TE2)) >> + msm_disp_snapshot_add_block(disp_state, sblk->te2.len, >> + mmio + base + sblk->te2.base, "%s_%s", >> + pingpong_block->name, sblk->te2.name); >> + >> + if (pingpong_block->features & BIT(DPU_PINGPONG_DITHER)) >> + msm_disp_snapshot_add_block(disp_state, sblk->dither.len, >> + mmio + base + sblk->dither.base, "%s_%s", >> + pingpong_block->name, sblk->dither.name); >> + break; >> + } >> + case DPU_HW_BLK_DSC: >> + { >> + struct dpu_dsc_cfg *dsc_block = (struct dpu_dsc_cfg *)blk; >> + >> + base = dsc_block->base; >> + >> + if (dsc_block->features & BIT(DPU_DSC_HW_REV_1_2)) { >> + struct dpu_dsc_blk enc = dsc_block->sblk->enc; >> + struct dpu_dsc_blk ctl = dsc_block->sblk->ctl; >> + >> + /* For now, pass in a length of 0 because the DSC_BLK >> register space >> + * overlaps with the sblks' register space. >> + * >> + * TODO: Pass in a length of 0 t0 DSC_BLK_1_2 in the HW >> catalog where >> + * applicable. > > Nice catch, thank you. We should fix that. > Yes and we would have fixed that ourself if you wanted that with this series as another patch.
On 6/23/2023 5:09 PM, Abhinav Kumar wrote: > > > On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >> On 23/06/2023 02:48, Ryan McCann wrote: >>> Currently, the device core dump mechanism does not dump registers of sub >>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>> function to dump hardware blocks that contain sub blocks. >>> >>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>> --- >>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>> +++++++++++++++++++++++++++----- >>> 1 file changed, 168 insertions(+), 26 deletions(-) >>> >>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> index aa8499de1b9f..9b1b1c382269 100644 >>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms >>> *kms) >>> return 0; >>> } >>> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >>> *disp_state, >>> + void __iomem *mmio, void *blk, >>> + enum dpu_hw_blk_type blk_type) >> >> No. Such multiplexers add no value to the code. Please inline it. >> >> Not to mention that this patch is hard to review. You both move >> existing code and add new features. If it were to go, it should have >> been split into two patches: one introducing the multiplexer and >> another one adding subblocks. >> > > Ok. we can split this into: > > 1) adding the multiplexer > 2) adding sub-blk parsing support inside the multiplexer > >>> +{ >>> + u32 base; >>> + >>> + switch (blk_type) { >>> + case DPU_HW_BLK_TOP: >>> + { >>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>> + >>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>> + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, >>> + mmio + top->base, "top"); >>> + msm_disp_snapshot_add_block(disp_state, top->len - >>> MDP_PERIPH_TOP0_END, >>> + mmio + top->base + MDP_PERIPH_TOP0_END, >>> + "top_2"); >>> + } else { >>> + msm_disp_snapshot_add_block(disp_state, top->len, mmio + >>> top->base, "top"); >>> + } >>> + break; >>> + } >>> + case DPU_HW_BLK_LM: >>> + { >>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + >>> mixer->base, "%s", >>> + mixer->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_CTL: >>> + { >>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >>> ctl->base, "%s", >>> + ctl->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_INTF: >>> + { >>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + >>> intf->base, "%s", >>> + intf->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_WB: >>> + { >>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>> wb->base, "%s", >>> + wb->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_SSPP: >>> + { >>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; >>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>> + >>> + base = sspp_block->base; >>> + >>> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, >>> mmio + base, "%s", >>> + sspp_block->name); >>> + >>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>> + msm_disp_snapshot_add_block(disp_state, >>> sblk->scaler_blk.len, >>> + mmio + base + sblk->scaler_blk.base, >>> "%s_%s", >>> + sspp_block->name, sblk->scaler_blk.name); >> >> Actually, it would be better to: >> - drop name from all sblk instances (and use known string instead of >> the sblk name here) Hey Dmitry, FWIW, I second Abhinav's points about the sblk names. For example, if in the future we want to add a "_rot" suffix specifically to the VIG_SBLK_ROT.scaler name, it would be easier to just make that change in the HW catalog. >> - Use sblk->foo_blk.len to check if it should be printed or not. From my understanding, your suggestion is to replace the feature flag checks with a sblk.len > 0 check. I don't think that would be good because it wouldn't be correct to assume that the sblk will always be present. For example, for DPU_HW_BLK_DSC, the sblks will only be present for DSC_BLK_1_2. In addition, it is possible for sblks, like pp_sblk_te.te2, to have a len of 0. While the register space of that specific sblk will not be printed, I'd prefer the devcore dump to reflect what is present within the HW catalog so that the user knows which pingpong blks have the TE2 sblk. Thanks, Jessica Zhang >> > > No, I dont agree. If we drop the names from the sub_blk in the catalog, > we will end up using "sub_blk_name" string here in the code to indicate > which blk that is in the dump. > > If we add more sub_blks in the catalog in the future we need to keep > changing the code over here. Thats not how it should be. > > Leaving the names in the catalog ensures that this code wont change and > only catalog changes when we add a new sub_blk either for an existing or > new chipset. > > catalog is indicating the new blk, and dumping code just prints it. > > with your approach, dumping code will or can keep changing with chipsets > or sub_blks. Thats not how it should be. > >>> + >>> + if (sspp_block->features & BIT(DPU_SSPP_CSC) || >>> sspp_block->features >>> + & BIT(DPU_SSPP_CSC_10BIT)) >> >> A very bad use of indentation. In future please split logically rather >> than just filling the line up to the line width. >> >>> + msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, >>> + mmio + base + sblk->csc_blk.base, "%s_%s", >>> + sspp_block->name, sblk->csc_blk.name); >>> + break; >>> + } >>> + case DPU_HW_BLK_DSPP: >>> + { >>> + struct dpu_dspp_cfg *dspp_block = (struct dpu_dspp_cfg *)blk; >>> + >>> + base = dspp_block->base; >>> + >>> + msm_disp_snapshot_add_block(disp_state, dspp_block->len, >>> mmio + base, "%s", >>> + dspp_block->name); >>> + >>> + if (dspp_block->features & BIT(DPU_DSPP_PCC)) >>> + msm_disp_snapshot_add_block(disp_state, >>> dspp_block->sblk->pcc.len, >>> + mmio + base + dspp_block->sblk->pcc.base, >>> + "%s_%s", dspp_block->name, >>> + dspp_block->sblk->pcc.name); >>> + break; >>> + } >>> + case DPU_HW_BLK_PINGPONG: >>> + { >>> + struct dpu_pingpong_cfg *pingpong_block = (struct >>> dpu_pingpong_cfg *)blk; >>> + const struct dpu_pingpong_sub_blks *sblk = >>> pingpong_block->sblk; >>> + >>> + base = pingpong_block->base; >>> + >>> + msm_disp_snapshot_add_block(disp_state, pingpong_block->len, >>> mmio + base, "%s", >>> + pingpong_block->name); >>> + >>> + if (pingpong_block->features & BIT(DPU_PINGPONG_TE2)) >>> + msm_disp_snapshot_add_block(disp_state, sblk->te2.len, >>> + mmio + base + sblk->te2.base, "%s_%s", >>> + pingpong_block->name, sblk->te2.name); >>> + >>> + if (pingpong_block->features & BIT(DPU_PINGPONG_DITHER)) >>> + msm_disp_snapshot_add_block(disp_state, sblk->dither.len, >>> + mmio + base + sblk->dither.base, "%s_%s", >>> + pingpong_block->name, sblk->dither.name); >>> + break; >>> + } >>> + case DPU_HW_BLK_DSC: >>> + { >>> + struct dpu_dsc_cfg *dsc_block = (struct dpu_dsc_cfg *)blk; >>> + >>> + base = dsc_block->base; >>> + >>> + if (dsc_block->features & BIT(DPU_DSC_HW_REV_1_2)) { >>> + struct dpu_dsc_blk enc = dsc_block->sblk->enc; >>> + struct dpu_dsc_blk ctl = dsc_block->sblk->ctl; >>> + >>> + /* For now, pass in a length of 0 because the DSC_BLK >>> register space >>> + * overlaps with the sblks' register space. >>> + * >>> + * TODO: Pass in a length of 0 t0 DSC_BLK_1_2 in the HW >>> catalog where >>> + * applicable. >> >> Nice catch, thank you. We should fix that. >> > > Yes and we would have fixed that ourself if you wanted that with this > series as another patch. >
On 24/06/2023 03:09, Abhinav Kumar wrote: > > > On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >> On 23/06/2023 02:48, Ryan McCann wrote: >>> Currently, the device core dump mechanism does not dump registers of sub >>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>> function to dump hardware blocks that contain sub blocks. >>> >>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>> --- >>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>> +++++++++++++++++++++++++++----- >>> 1 file changed, 168 insertions(+), 26 deletions(-) >>> >>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> index aa8499de1b9f..9b1b1c382269 100644 >>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms >>> *kms) >>> return 0; >>> } >>> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >>> *disp_state, >>> + void __iomem *mmio, void *blk, >>> + enum dpu_hw_blk_type blk_type) >> >> No. Such multiplexers add no value to the code. Please inline it. >> >> Not to mention that this patch is hard to review. You both move >> existing code and add new features. If it were to go, it should have >> been split into two patches: one introducing the multiplexer and >> another one adding subblocks. >> > > Ok. we can split this into: > > 1) adding the multiplexer > 2) adding sub-blk parsing support inside the multiplexer I'd say, drop the multiplexer completely. It adds no value here. It is only used from dpu_kms_mdp_snapshot(). If the code there was complex enough, it would have made sense to _split_ the function. But even in such case there would be no point in having multiplexer. We do not enumerate block by type. > >>> +{ >>> + u32 base; >>> + >>> + switch (blk_type) { >>> + case DPU_HW_BLK_TOP: >>> + { >>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>> + >>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>> + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, >>> + mmio + top->base, "top"); >>> + msm_disp_snapshot_add_block(disp_state, top->len - >>> MDP_PERIPH_TOP0_END, >>> + mmio + top->base + MDP_PERIPH_TOP0_END, >>> + "top_2"); >>> + } else { >>> + msm_disp_snapshot_add_block(disp_state, top->len, mmio + >>> top->base, "top"); >>> + } >>> + break; >>> + } >>> + case DPU_HW_BLK_LM: >>> + { >>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + >>> mixer->base, "%s", >>> + mixer->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_CTL: >>> + { >>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >>> ctl->base, "%s", >>> + ctl->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_INTF: >>> + { >>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + >>> intf->base, "%s", >>> + intf->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_WB: >>> + { >>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>> + >>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>> wb->base, "%s", >>> + wb->name); >>> + break; >>> + } >>> + case DPU_HW_BLK_SSPP: >>> + { >>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; >>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>> + >>> + base = sspp_block->base; >>> + >>> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, >>> mmio + base, "%s", >>> + sspp_block->name); >>> + >>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>> + msm_disp_snapshot_add_block(disp_state, >>> sblk->scaler_blk.len, >>> + mmio + base + sblk->scaler_blk.base, >>> "%s_%s", >>> + sspp_block->name, sblk->scaler_blk.name); >> >> Actually, it would be better to: >> - drop name from all sblk instances (and use known string instead of >> the sblk name here) >> - Use sblk->foo_blk.len to check if it should be printed or not. >> > > No, I dont agree. If we drop the names from the sub_blk in the catalog, > we will end up using "sub_blk_name" string here in the code to indicate > which blk that is in the dump. > > If we add more sub_blks in the catalog in the future we need to keep > changing the code over here. Thats not how it should be. > > Leaving the names in the catalog ensures that this code wont change and > only catalog changes when we add a new sub_blk either for an existing or > new chipset. > > catalog is indicating the new blk, and dumping code just prints it. > > with your approach, dumping code will or can keep changing with chipsets > or sub_blks. Thats not how it should be. Well, we do not enumerate sub-blocks in any way, they are not indexed. So even with sblk->blk.name in place, adding new sub-block would require adding new code here. That's why I wrote that the calling code knows which sub-block it refers to. Let me extract the relevant code (skipping all the conditions for now): msm_disp_snapshot_add_block(disp_state, sspp_block->len, mmio + base, "%s", sspp_block->name); if (have_scaler) msm_disp_snapshot_add_block(disp_state, sblk->scaler_blk.len, mmio + base + sblk->scaler_blk.base, "%s_%s", sspp_block->name, sblk->scaler_blk.name); if (have_csc) msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, mmio + base + sblk->csc_blk.base, "%s_%s", sspp_block->name, sblk->csc_blk.name); Consider adding new sub-block, "baz". We would still require manual addition of the following code: msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, mmio + base + sblk->baz_blk.base, "%s_%s", sspp_block->name, sblk->baz_blk.name); Compare this with: msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, mmio + base + sblk->baz_blk.base, "%s_baz", sspp_block->name); Moreover, if we follow the style of dpu_kms_mdp_snapshot() (which doesn't use name), it should be: msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, mmio + base + sblk->baz_blk.base, "sspp%d_baz", idx); > >>> + >>> + if (sspp_block->features & BIT(DPU_SSPP_CSC) || >>> sspp_block->features >>> + & BIT(DPU_SSPP_CSC_10BIT)) >> >> A very bad use of indentation. In future please split logically rather >> than just filling the line up to the line width. >> >>> + msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, >>> + mmio + base + sblk->csc_blk.base, "%s_%s", >>> + sspp_block->name, sblk->csc_blk.name); >>> + break; >>> + } >>> + case DPU_HW_BLK_DSPP: >>> + { >>> + struct dpu_dspp_cfg *dspp_block = (struct dpu_dspp_cfg *)blk; >>> + >>> + base = dspp_block->base; >>> + >>> + msm_disp_snapshot_add_block(disp_state, dspp_block->len, >>> mmio + base, "%s", >>> + dspp_block->name); >>> + >>> + if (dspp_block->features & BIT(DPU_DSPP_PCC)) >>> + msm_disp_snapshot_add_block(disp_state, >>> dspp_block->sblk->pcc.len, >>> + mmio + base + dspp_block->sblk->pcc.base, >>> + "%s_%s", dspp_block->name, >>> + dspp_block->sblk->pcc.name); >>> + break; >>> + } >>> + case DPU_HW_BLK_PINGPONG: >>> + { >>> + struct dpu_pingpong_cfg *pingpong_block = (struct >>> dpu_pingpong_cfg *)blk; >>> + const struct dpu_pingpong_sub_blks *sblk = >>> pingpong_block->sblk; >>> + >>> + base = pingpong_block->base; >>> + >>> + msm_disp_snapshot_add_block(disp_state, pingpong_block->len, >>> mmio + base, "%s", >>> + pingpong_block->name); >>> + >>> + if (pingpong_block->features & BIT(DPU_PINGPONG_TE2)) >>> + msm_disp_snapshot_add_block(disp_state, sblk->te2.len, >>> + mmio + base + sblk->te2.base, "%s_%s", >>> + pingpong_block->name, sblk->te2.name); >>> + >>> + if (pingpong_block->features & BIT(DPU_PINGPONG_DITHER)) >>> + msm_disp_snapshot_add_block(disp_state, sblk->dither.len, >>> + mmio + base + sblk->dither.base, "%s_%s", >>> + pingpong_block->name, sblk->dither.name); >>> + break; >>> + } >>> + case DPU_HW_BLK_DSC: >>> + { >>> + struct dpu_dsc_cfg *dsc_block = (struct dpu_dsc_cfg *)blk; >>> + >>> + base = dsc_block->base; >>> + >>> + if (dsc_block->features & BIT(DPU_DSC_HW_REV_1_2)) { >>> + struct dpu_dsc_blk enc = dsc_block->sblk->enc; >>> + struct dpu_dsc_blk ctl = dsc_block->sblk->ctl; >>> + >>> + /* For now, pass in a length of 0 because the DSC_BLK >>> register space >>> + * overlaps with the sblks' register space. >>> + * >>> + * TODO: Pass in a length of 0 t0 DSC_BLK_1_2 in the HW >>> catalog where >>> + * applicable. >> >> Nice catch, thank you. We should fix that. >> > > Yes and we would have fixed that ourself if you wanted that with this > series as another patch. This is not relevant to this series, so it should be fixed in a separate series.
On 24/06/2023 04:23, Jessica Zhang wrote: > > > On 6/23/2023 5:09 PM, Abhinav Kumar wrote: >> >> >> On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >>> On 23/06/2023 02:48, Ryan McCann wrote: >>>> Currently, the device core dump mechanism does not dump registers of >>>> sub >>>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>>> function to dump hardware blocks that contain sub blocks. >>>> >>>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>>> --- >>>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>>> +++++++++++++++++++++++++++----- >>>> 1 file changed, 168 insertions(+), 26 deletions(-) >>>> >>>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> index aa8499de1b9f..9b1b1c382269 100644 >>>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms >>>> *kms) >>>> return 0; >>>> } >>>> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >>>> *disp_state, >>>> + void __iomem *mmio, void *blk, >>>> + enum dpu_hw_blk_type blk_type) >>> >>> No. Such multiplexers add no value to the code. Please inline it. >>> >>> Not to mention that this patch is hard to review. You both move >>> existing code and add new features. If it were to go, it should have >>> been split into two patches: one introducing the multiplexer and >>> another one adding subblocks. >>> >> >> Ok. we can split this into: >> >> 1) adding the multiplexer >> 2) adding sub-blk parsing support inside the multiplexer >> >>>> +{ >>>> + u32 base; >>>> + >>>> + switch (blk_type) { >>>> + case DPU_HW_BLK_TOP: >>>> + { >>>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>>> + >>>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>>> + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, >>>> + mmio + top->base, "top"); >>>> + msm_disp_snapshot_add_block(disp_state, top->len - >>>> MDP_PERIPH_TOP0_END, >>>> + mmio + top->base + MDP_PERIPH_TOP0_END, >>>> + "top_2"); >>>> + } else { >>>> + msm_disp_snapshot_add_block(disp_state, top->len, mmio >>>> + top->base, "top"); >>>> + } >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_LM: >>>> + { >>>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + >>>> mixer->base, "%s", >>>> + mixer->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_CTL: >>>> + { >>>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >>>> ctl->base, "%s", >>>> + ctl->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_INTF: >>>> + { >>>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + >>>> intf->base, "%s", >>>> + intf->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_WB: >>>> + { >>>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>>> wb->base, "%s", >>>> + wb->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_SSPP: >>>> + { >>>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; >>>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>>> + >>>> + base = sspp_block->base; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, >>>> mmio + base, "%s", >>>> + sspp_block->name); >>>> + >>>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>>> + msm_disp_snapshot_add_block(disp_state, >>>> sblk->scaler_blk.len, >>>> + mmio + base + sblk->scaler_blk.base, >>>> "%s_%s", >>>> + sspp_block->name, sblk->scaler_blk.name); >>> >>> Actually, it would be better to: >>> - drop name from all sblk instances (and use known string instead of >>> the sblk name here) > > Hey Dmitry, > > FWIW, I second Abhinav's points about the sblk names. For example, if in > the future we want to add a "_rot" suffix specifically to the > VIG_SBLK_ROT.scaler name, it would be easier to just make that change in > the HW catalog. But why? The scaler is the same qseed3 scaler. We do not dump features, they are constant for the platform in question. > >>> - Use sblk->foo_blk.len to check if it should be printed or not. > From my understanding, your suggestion is to replace the feature flag > checks with a sblk.len > 0 check. > > I don't think that would be good because it wouldn't be correct to > assume that the sblk will always be present. For example, for > DPU_HW_BLK_DSC, the sblks will only be present for DSC_BLK_1_2. I don't consider sub-block as being always present. But if it present, it has non-zero length. If its length is zero, we have nothing to dump for it. > In addition, it is possible for sblks, like pp_sblk_te.te2, to have a > len of 0. While the register space of that specific sblk will not be > printed, I'd prefer the devcore dump to reflect what is present within > the HW catalog so that the user knows which pingpong blks have the TE2 > sblk. I'd consider this as dumping the feature instead of dumping the registers. If you think it is necessary to ease decoding of the dump, consider adding block.features to the dump instead. > > Thanks, > > Jessica Zhang > >>> >> >> No, I dont agree. If we drop the names from the sub_blk in the >> catalog, we will end up using "sub_blk_name" string here in the code >> to indicate which blk that is in the dump. >> >> If we add more sub_blks in the catalog in the future we need to keep >> changing the code over here. Thats not how it should be. >> >> Leaving the names in the catalog ensures that this code wont change >> and only catalog changes when we add a new sub_blk either for an >> existing or new chipset. >> >> catalog is indicating the new blk, and dumping code just prints it. >> >> with your approach, dumping code will or can keep changing with >> chipsets or sub_blks. Thats not how it should be. >>
On 23/06/2023 02:48, Ryan McCann wrote: > Currently, the device core dump mechanism does not dump registers of sub > blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper > function to dump hardware blocks that contain sub blocks. > > Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> > --- > drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 +++++++++++++++++++++++++++----- > 1 file changed, 168 insertions(+), 26 deletions(-) > > diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c > index aa8499de1b9f..9b1b1c382269 100644 > --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c > +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c > @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms *kms) > return 0; > } > > +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state *disp_state, > + void __iomem *mmio, void *blk, > + enum dpu_hw_blk_type blk_type) > +{ > + u32 base; > + > + switch (blk_type) { > + case DPU_HW_BLK_TOP: > + { > + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; Block configuration is constant, so these should be constant pointers. Not to mention that such type conversions are usually considered to be a bad idea. We loose type information, so compiler can not catch any errors here. > + > + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { > + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, > + mmio + top->base, "top"); > + msm_disp_snapshot_add_block(disp_state, top->len - MDP_PERIPH_TOP0_END, > + mmio + top->base + MDP_PERIPH_TOP0_END, > + "top_2"); > + } else { > + msm_disp_snapshot_add_block(disp_state, top->len, mmio + top->base, "top"); > + } > + break; [skipped] default: > + DPU_ERROR("Block type not supported."); Which block type? > + } > +} > + > static void dpu_kms_mdp_snapshot(struct msm_disp_state *disp_state, struct msm_kms *kms) > { > int i; > @@ -899,53 +1047,47 @@ static void dpu_kms_mdp_snapshot(struct msm_disp_state *disp_state, struct msm_k > > /* dump CTL sub-blocks HW regs info */ > for (i = 0; i < cat->ctl_count; i++) > - msm_disp_snapshot_add_block(disp_state, cat->ctl[i].len, > - dpu_kms->mmio + cat->ctl[i].base, "ctl_%d", i); > + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->ctl[i], Here we are loosing the const property, which is a bad idea. > + DPU_HW_BLK_CTL);
On 6/24/2023 5:07 AM, Dmitry Baryshkov wrote: > On 24/06/2023 03:09, Abhinav Kumar wrote: >> >> >> On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >>> On 23/06/2023 02:48, Ryan McCann wrote: >>>> Currently, the device core dump mechanism does not dump registers of >>>> sub >>>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>>> function to dump hardware blocks that contain sub blocks. >>>> >>>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>>> --- >>>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>>> +++++++++++++++++++++++++++----- >>>> 1 file changed, 168 insertions(+), 26 deletions(-) >>>> >>>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> index aa8499de1b9f..9b1b1c382269 100644 >>>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms >>>> *kms) >>>> return 0; >>>> } >>>> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >>>> *disp_state, >>>> + void __iomem *mmio, void *blk, >>>> + enum dpu_hw_blk_type blk_type) >>> >>> No. Such multiplexers add no value to the code. Please inline it. >>> >>> Not to mention that this patch is hard to review. You both move >>> existing code and add new features. If it were to go, it should have >>> been split into two patches: one introducing the multiplexer and >>> another one adding subblocks. >>> >> >> Ok. we can split this into: >> >> 1) adding the multiplexer >> 2) adding sub-blk parsing support inside the multiplexer > > I'd say, drop the multiplexer completely. It adds no value here. It is > only used from dpu_kms_mdp_snapshot(). If the code there was complex > enough, it would have made sense to _split_ the function. But even in > such case there would be no point in having multiplexer. We do not > enumerate block by type. > Can you pls elaborate what you mean by enumerate blk by type? We do have DPU_HW_BLK_*** Did you mean sub-blk? >> >>>> +{ >>>> + u32 base; >>>> + >>>> + switch (blk_type) { >>>> + case DPU_HW_BLK_TOP: >>>> + { >>>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>>> + >>>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>>> + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, >>>> + mmio + top->base, "top"); >>>> + msm_disp_snapshot_add_block(disp_state, top->len - >>>> MDP_PERIPH_TOP0_END, >>>> + mmio + top->base + MDP_PERIPH_TOP0_END, >>>> + "top_2"); >>>> + } else { >>>> + msm_disp_snapshot_add_block(disp_state, top->len, mmio >>>> + top->base, "top"); >>>> + } >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_LM: >>>> + { >>>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + >>>> mixer->base, "%s", >>>> + mixer->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_CTL: >>>> + { >>>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >>>> ctl->base, "%s", >>>> + ctl->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_INTF: >>>> + { >>>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + >>>> intf->base, "%s", >>>> + intf->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_WB: >>>> + { >>>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>>> wb->base, "%s", >>>> + wb->name); >>>> + break; >>>> + } >>>> + case DPU_HW_BLK_SSPP: >>>> + { >>>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; >>>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>>> + >>>> + base = sspp_block->base; >>>> + >>>> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, >>>> mmio + base, "%s", >>>> + sspp_block->name); >>>> + >>>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>>> + msm_disp_snapshot_add_block(disp_state, >>>> sblk->scaler_blk.len, >>>> + mmio + base + sblk->scaler_blk.base, >>>> "%s_%s", >>>> + sspp_block->name, sblk->scaler_blk.name); >>> >>> Actually, it would be better to: >>> - drop name from all sblk instances (and use known string instead of >>> the sblk name here) >>> - Use sblk->foo_blk.len to check if it should be printed or not. >>> >> >> No, I dont agree. If we drop the names from the sub_blk in the >> catalog, we will end up using "sub_blk_name" string here in the code >> to indicate which blk that is in the dump. >> >> If we add more sub_blks in the catalog in the future we need to keep >> changing the code over here. Thats not how it should be. >> >> Leaving the names in the catalog ensures that this code wont change >> and only catalog changes when we add a new sub_blk either for an >> existing or new chipset. >> >> catalog is indicating the new blk, and dumping code just prints it. >> >> with your approach, dumping code will or can keep changing with >> chipsets or sub_blks. Thats not how it should be. > > Well, we do not enumerate sub-blocks in any way, they are not indexed. > So even with sblk->blk.name in place, adding new sub-block would require > adding new code here. That's why I wrote that the calling code knows > which sub-block it refers to. > Today, unfortunately each sub_blk type is different so we have to do this case by case. Ideally, this should have just been -> print main blk -> print all sub-blks of the main blk Without having to handle each main blk's sub-blks separately. That way the dumping code would have remained generic without having to do even the multiplexer in the first place. Need to explore if somehow we can come up with a generic sub-blk struct and make this possible. Then this code will become much easier and what I am saying will make total sense. Even without that, conceptually these sub-blk names are reflecting whats in our software document. So its not a random name but reflects the actual sub-blk name from the hardware. So this belongs in the catalog. Dumping code should not change or know whats the name of each block. It should just use whats in the catalog. thats why even conceptually I am not okay with your idea. > Let me extract the relevant code (skipping all the conditions for now): > > msm_disp_snapshot_add_block(disp_state, sspp_block->len, mmio + base, "%s", > sspp_block->name); > > if (have_scaler) > msm_disp_snapshot_add_block(disp_state, sblk->scaler_blk.len, > mmio + base + sblk->scaler_blk.base, "%s_%s", > sspp_block->name, sblk->scaler_blk.name); > > if (have_csc) > msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, > mmio + base + sblk->csc_blk.base, "%s_%s", > sspp_block->name, sblk->csc_blk.name); > > Consider adding new sub-block, "baz". We would still require manual > addition of the following code: > > msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, > mmio + base + sblk->baz_blk.base, "%s_%s", > sspp_block->name, sblk->baz_blk.name); > > > Compare this with: > > msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, > mmio + base + sblk->baz_blk.base, "%s_baz", > sspp_block->name); > Basically you are saying why not make the one line change here instead of using the name from the catalog. I think it will be better to use from the catalog for the reason I wrote above that dumping code should just "use" the catalog's information and not become a catalog itself. You are not saving much by dropping the sub-blk name from catalog anyway. > Moreover, if we follow the style of dpu_kms_mdp_snapshot() (which > doesn't use name), it should be: > > msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, > mmio + base + sblk->baz_blk.base, "sspp%d_baz", idx); > > tbh, after looking at this series, it made me think why I didnt use the name from the catalog even for the dpu_kms_mdp_snapshot() > >> <snipped>
On 24/06/2023 17:17, Abhinav Kumar wrote: > > > On 6/24/2023 5:07 AM, Dmitry Baryshkov wrote: >> On 24/06/2023 03:09, Abhinav Kumar wrote: >>> >>> >>> On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >>>> On 23/06/2023 02:48, Ryan McCann wrote: >>>>> Currently, the device core dump mechanism does not dump registers >>>>> of sub >>>>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>>>> function to dump hardware blocks that contain sub blocks. >>>>> >>>>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>>>> --- >>>>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>>>> +++++++++++++++++++++++++++----- >>>>> 1 file changed, 168 insertions(+), 26 deletions(-) >>>>> >>>>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>> index aa8499de1b9f..9b1b1c382269 100644 >>>>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms >>>>> *kms) >>>>> return 0; >>>>> } >>>>> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >>>>> *disp_state, >>>>> + void __iomem *mmio, void *blk, >>>>> + enum dpu_hw_blk_type blk_type) >>>> >>>> No. Such multiplexers add no value to the code. Please inline it. >>>> >>>> Not to mention that this patch is hard to review. You both move >>>> existing code and add new features. If it were to go, it should have >>>> been split into two patches: one introducing the multiplexer and >>>> another one adding subblocks. >>>> >>> >>> Ok. we can split this into: >>> >>> 1) adding the multiplexer >>> 2) adding sub-blk parsing support inside the multiplexer >> >> I'd say, drop the multiplexer completely. It adds no value here. It is >> only used from dpu_kms_mdp_snapshot(). If the code there was complex >> enough, it would have made sense to _split_ the function. But even in >> such case there would be no point in having multiplexer. We do not >> enumerate block by type. >> > > Can you pls elaborate what you mean by enumerate blk by type? > > We do have DPU_HW_BLK_*** > > Did you mean sub-blk? > >>> >>>>> +{ >>>>> + u32 base; >>>>> + >>>>> + switch (blk_type) { >>>>> + case DPU_HW_BLK_TOP: >>>>> + { >>>>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>>>> + >>>>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>>>> + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, >>>>> + mmio + top->base, "top"); >>>>> + msm_disp_snapshot_add_block(disp_state, top->len - >>>>> MDP_PERIPH_TOP0_END, >>>>> + mmio + top->base + MDP_PERIPH_TOP0_END, >>>>> + "top_2"); >>>>> + } else { >>>>> + msm_disp_snapshot_add_block(disp_state, top->len, mmio >>>>> + top->base, "top"); >>>>> + } >>>>> + break; >>>>> + } >>>>> + case DPU_HW_BLK_LM: >>>>> + { >>>>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>>>> + >>>>> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + >>>>> mixer->base, "%s", >>>>> + mixer->name); >>>>> + break; >>>>> + } >>>>> + case DPU_HW_BLK_CTL: >>>>> + { >>>>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>>>> + >>>>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >>>>> ctl->base, "%s", >>>>> + ctl->name); >>>>> + break; >>>>> + } >>>>> + case DPU_HW_BLK_INTF: >>>>> + { >>>>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>>>> + >>>>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + >>>>> intf->base, "%s", >>>>> + intf->name); >>>>> + break; >>>>> + } >>>>> + case DPU_HW_BLK_WB: >>>>> + { >>>>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>>>> + >>>>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>>>> wb->base, "%s", >>>>> + wb->name); >>>>> + break; >>>>> + } >>>>> + case DPU_HW_BLK_SSPP: >>>>> + { >>>>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; >>>>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>>>> + >>>>> + base = sspp_block->base; >>>>> + >>>>> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, >>>>> mmio + base, "%s", >>>>> + sspp_block->name); >>>>> + >>>>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>>>> + msm_disp_snapshot_add_block(disp_state, >>>>> sblk->scaler_blk.len, >>>>> + mmio + base + sblk->scaler_blk.base, >>>>> "%s_%s", >>>>> + sspp_block->name, sblk->scaler_blk.name); >>>> >>>> Actually, it would be better to: >>>> - drop name from all sblk instances (and use known string instead of >>>> the sblk name here) >>>> - Use sblk->foo_blk.len to check if it should be printed or not. >>>> >>> >>> No, I dont agree. If we drop the names from the sub_blk in the >>> catalog, we will end up using "sub_blk_name" string here in the code >>> to indicate which blk that is in the dump. >>> >>> If we add more sub_blks in the catalog in the future we need to keep >>> changing the code over here. Thats not how it should be. >>> >>> Leaving the names in the catalog ensures that this code wont change >>> and only catalog changes when we add a new sub_blk either for an >>> existing or new chipset. >>> >>> catalog is indicating the new blk, and dumping code just prints it. >>> >>> with your approach, dumping code will or can keep changing with >>> chipsets or sub_blks. Thats not how it should be. >> >> Well, we do not enumerate sub-blocks in any way, they are not indexed. >> So even with sblk->blk.name in place, adding new sub-block would >> require adding new code here. That's why I wrote that the calling code >> knows which sub-block it refers to. >> > > Today, unfortunately each sub_blk type is different so we have to do > this case by case. > > Ideally, this should have just been > > -> print main blk > -> print all sub-blks of the main blk > > Without having to handle each main blk's sub-blks separately. > > That way the dumping code would have remained generic without having to > do even the multiplexer in the first place. > > Need to explore if somehow we can come up with a generic sub-blk struct > and make this possible. Then this code will become much easier and what > I am saying will make total sense. In such case, yes. However I'd warn about having a generic array of subblocks. Having named subblock entries might complicate snapshotting, but it makes the rest of the DPU driver smaller. > > Even without that, conceptually these sub-blk names are reflecting whats > in our software document. So its not a random name but reflects the > actual sub-blk name from the hardware. Yes > So this belongs in the catalog. But the sub-block field already has a correct name: scaler_blk, csc_blk, etc. Having both sub-block field name and the .name inside results in kind of duplication, which seems unnecessary to me. > Dumping code should not change or know whats the name of each block. It > should just use whats in the catalog. thats why even conceptually I am > not okay with your idea. Dumping code itself (msm_disp_snapshot_*) doesn't. But the caller code knows what is the subblock. Let me pick a definition from the patch: static const struct dpu_dspp_sub_blks msm8998_dspp_sblk = { .pcc = {.name = "pcc", .id = DPU_DSPP_PCC, .base = 0x1700, .len = 0x90, .version = 0x10007}, }; the "pcc" is repeated three times. When the code looks at this block, it already knows that it is a PCC block. Compare this with: static const struct dpu_dspp_sub_blks msm8998_dspp_sblk = { .pcc = { .base = 0x1700, .len = 0x90, .version = 0x10007, }, }; Nothing is repeated, but we still know that this is the DSPPn_PCC sub-block description. Calling code does: u32 base; base = ctx->cap->sblk->pcc.base; > >> Let me extract the relevant code (skipping all the conditions for now): >> >> msm_disp_snapshot_add_block(disp_state, sspp_block->len, mmio + base, >> "%s", >> sspp_block->name); >> >> if (have_scaler) >> msm_disp_snapshot_add_block(disp_state, sblk->scaler_blk.len, >> mmio + base + sblk->scaler_blk.base, "%s_%s", >> sspp_block->name, sblk->scaler_blk.name); >> >> if (have_csc) >> msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, >> mmio + base + sblk->csc_blk.base, "%s_%s", >> sspp_block->name, sblk->csc_blk.name); >> >> Consider adding new sub-block, "baz". We would still require manual >> addition of the following code: >> >> msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, >> mmio + base + sblk->baz_blk.base, "%s_%s", >> sspp_block->name, sblk->baz_blk.name); >> >> >> Compare this with: >> >> msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, >> mmio + base + sblk->baz_blk.base, "%s_baz", >> sspp_block->name); >> > > Basically you are saying why not make the one line change here instead > of using the name from the catalog. > > I think it will be better to use from the catalog for the reason I wrote > above that dumping code should just "use" the catalog's information and > not become a catalog itself. > > You are not saving much by dropping the sub-blk name from catalog anyway. > >> Moreover, if we follow the style of dpu_kms_mdp_snapshot() (which >> doesn't use name), it should be: >> >> msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, >> mmio + base + sblk->baz_blk.base, "sspp%d_baz", >> idx); >> >> > tbh, after looking at this series, it made me think why I didnt use the > name from the catalog even for the dpu_kms_mdp_snapshot() >> >>> > > <snipped>
On 6/24/2023 8:03 AM, Dmitry Baryshkov wrote: > On 24/06/2023 17:17, Abhinav Kumar wrote: >> >> >> On 6/24/2023 5:07 AM, Dmitry Baryshkov wrote: >>> On 24/06/2023 03:09, Abhinav Kumar wrote: >>>> >>>> >>>> On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >>>>> On 23/06/2023 02:48, Ryan McCann wrote: >>>>>> Currently, the device core dump mechanism does not dump registers >>>>>> of sub >>>>>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>>>>> function to dump hardware blocks that contain sub blocks. >>>>>> >>>>>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>>>>> --- >>>>>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>>>>> +++++++++++++++++++++++++++----- >>>>>> 1 file changed, 168 insertions(+), 26 deletions(-) >>>>>> >>>>>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>> index aa8499de1b9f..9b1b1c382269 100644 >>>>>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct >>>>>> msm_kms *kms) >>>>>> return 0; >>>>>> } >>>>>> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >>>>>> *disp_state, >>>>>> + void __iomem *mmio, void *blk, >>>>>> + enum dpu_hw_blk_type blk_type) >>>>> >>>>> No. Such multiplexers add no value to the code. Please inline it. >>>>> >>>>> Not to mention that this patch is hard to review. You both move >>>>> existing code and add new features. If it were to go, it should >>>>> have been split into two patches: one introducing the multiplexer >>>>> and another one adding subblocks. >>>>> >>>> >>>> Ok. we can split this into: >>>> >>>> 1) adding the multiplexer >>>> 2) adding sub-blk parsing support inside the multiplexer >>> >>> I'd say, drop the multiplexer completely. It adds no value here. It >>> is only used from dpu_kms_mdp_snapshot(). If the code there was >>> complex enough, it would have made sense to _split_ the function. But >>> even in such case there would be no point in having multiplexer. We >>> do not enumerate block by type. >>> >> >> Can you pls elaborate what you mean by enumerate blk by type? >> >> We do have DPU_HW_BLK_*** >> >> Did you mean sub-blk? >> >>>> >>>>>> +{ >>>>>> + u32 base; >>>>>> + >>>>>> + switch (blk_type) { >>>>>> + case DPU_HW_BLK_TOP: >>>>>> + { >>>>>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>>>>> + >>>>>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>>>>> + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, >>>>>> + mmio + top->base, "top"); >>>>>> + msm_disp_snapshot_add_block(disp_state, top->len - >>>>>> MDP_PERIPH_TOP0_END, >>>>>> + mmio + top->base + MDP_PERIPH_TOP0_END, >>>>>> + "top_2"); >>>>>> + } else { >>>>>> + msm_disp_snapshot_add_block(disp_state, top->len, >>>>>> mmio + top->base, "top"); >>>>>> + } >>>>>> + break; >>>>>> + } >>>>>> + case DPU_HW_BLK_LM: >>>>>> + { >>>>>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>>>>> + >>>>>> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio >>>>>> + mixer->base, "%s", >>>>>> + mixer->name); >>>>>> + break; >>>>>> + } >>>>>> + case DPU_HW_BLK_CTL: >>>>>> + { >>>>>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>>>>> + >>>>>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >>>>>> ctl->base, "%s", >>>>>> + ctl->name); >>>>>> + break; >>>>>> + } >>>>>> + case DPU_HW_BLK_INTF: >>>>>> + { >>>>>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>>>>> + >>>>>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + >>>>>> intf->base, "%s", >>>>>> + intf->name); >>>>>> + break; >>>>>> + } >>>>>> + case DPU_HW_BLK_WB: >>>>>> + { >>>>>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>>>>> + >>>>>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>>>>> wb->base, "%s", >>>>>> + wb->name); >>>>>> + break; >>>>>> + } >>>>>> + case DPU_HW_BLK_SSPP: >>>>>> + { >>>>>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg >>>>>> *)blk; >>>>>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>>>>> + >>>>>> + base = sspp_block->base; >>>>>> + >>>>>> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, >>>>>> mmio + base, "%s", >>>>>> + sspp_block->name); >>>>>> + >>>>>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>>>>> + sspp_block->features & >>>>>> BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>>>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>>>>> + msm_disp_snapshot_add_block(disp_state, >>>>>> sblk->scaler_blk.len, >>>>>> + mmio + base + sblk->scaler_blk.base, >>>>>> "%s_%s", >>>>>> + sspp_block->name, >>>>>> sblk->scaler_blk.name); >>>>> >>>>> Actually, it would be better to: >>>>> - drop name from all sblk instances (and use known string instead >>>>> of the sblk name here) >>>>> - Use sblk->foo_blk.len to check if it should be printed or not. >>>>> >>>> >>>> No, I dont agree. If we drop the names from the sub_blk in the >>>> catalog, we will end up using "sub_blk_name" string here in the code >>>> to indicate which blk that is in the dump. >>>> >>>> If we add more sub_blks in the catalog in the future we need to keep >>>> changing the code over here. Thats not how it should be. >>>> >>>> Leaving the names in the catalog ensures that this code wont change >>>> and only catalog changes when we add a new sub_blk either for an >>>> existing or new chipset. >>>> >>>> catalog is indicating the new blk, and dumping code just prints it. >>>> >>>> with your approach, dumping code will or can keep changing with >>>> chipsets or sub_blks. Thats not how it should be. >>> >>> Well, we do not enumerate sub-blocks in any way, they are not >>> indexed. So even with sblk->blk.name in place, adding new sub-block >>> would require adding new code here. That's why I wrote that the >>> calling code knows which sub-block it refers to. >>> >> >> Today, unfortunately each sub_blk type is different so we have to do >> this case by case. >> >> Ideally, this should have just been >> >> -> print main blk >> -> print all sub-blks of the main blk >> >> Without having to handle each main blk's sub-blks separately. >> >> That way the dumping code would have remained generic without having >> to do even the multiplexer in the first place. >> >> Need to explore if somehow we can come up with a generic sub-blk >> struct and make this possible. Then this code will become much easier >> and what I am saying will make total sense. > > In such case, yes. However I'd warn about having a generic array of > subblocks. Having named subblock entries might complicate snapshotting, > but it makes the rest of the DPU driver smaller. > Need to explore this. But not immediately. >> >> Even without that, conceptually these sub-blk names are reflecting >> whats in our software document. So its not a random name but reflects >> the actual sub-blk name from the hardware. > > Yes > >> So this belongs in the catalog. > > But the sub-block field already has a correct name: scaler_blk, csc_blk, > etc. Having both sub-block field name and the .name inside results in > kind of duplication, which seems unnecessary to me. > No, there is a difference and not duplicated. One is the name of the struct so it can really be anything and doesnt need to match the hw doc name. But the other is the string name which we can give exactly to match software interface doc and makes parsing such a dump much much easier. One point I dont see you have considered is the block index of the sub_blk. Today, yes I see only a "pcc" or a "dither" etc What if there are two PCCs or two dithers. Then their names can just be "pcc_0" and "pcc_1" or "dither_0" and "dither_1". Having name gives us the ability to easily incorporate even unsequential indices. For example, every sspp's name today is not sequential. it can be "sspp_3" then "sspp_8" etc By having names reflect the correct indices, dumping code becomes less complex as the catalog will still have the right names as dumping code will just use that. >> Dumping code should not change or know whats the name of each block. >> It should just use whats in the catalog. thats why even conceptually I >> am not okay with your idea. > > Dumping code itself (msm_disp_snapshot_*) doesn't. But the caller code > knows what is the subblock. > But this is the dumping code because we are adding which blocks to dump. > Let me pick a definition from the patch: > > static const struct dpu_dspp_sub_blks msm8998_dspp_sblk = { > .pcc = {.name = "pcc", .id = DPU_DSPP_PCC, .base = 0x1700, > .len = 0x90, .version = 0x10007}, > }; > > the "pcc" is repeated three times. When the code looks at this block, it > already knows that it is a PCC block. > I agree with you about the "id" though. From what I can see in this patch, "id" is not used and we can drop that. So that change from your series is fine with me. But the pcc is the struct name which doesnt really need to reflect the hw name but the name field of the PCC should IMO. > Compare this with: > > static const struct dpu_dspp_sub_blks msm8998_dspp_sblk = { > .pcc = { > .base = 0x1700, > .len = 0x90, > .version = 0x10007, > }, > }; > > Nothing is repeated, but we still know that this is the DSPPn_PCC > sub-block description. > > Calling code does: > > u32 base; > base = ctx->cap->sblk->pcc.base; > > >> >>> Let me extract the relevant code (skipping all the conditions for now): >>> >>> msm_disp_snapshot_add_block(disp_state, sspp_block->len, mmio + base, >>> "%s", >>> sspp_block->name); >>> >>> if (have_scaler) >>> msm_disp_snapshot_add_block(disp_state, sblk->scaler_blk.len, >>> mmio + base + sblk->scaler_blk.base, "%s_%s", >>> sspp_block->name, sblk->scaler_blk.name); >>> >>> if (have_csc) >>> msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, >>> mmio + base + sblk->csc_blk.base, "%s_%s", >>> sspp_block->name, sblk->csc_blk.name); >>> >>> Consider adding new sub-block, "baz". We would still require manual >>> addition of the following code: >>> >>> msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, >>> mmio + base + sblk->baz_blk.base, "%s_%s", >>> sspp_block->name, sblk->baz_blk.name); >>> >>> >>> Compare this with: >>> >>> msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, >>> mmio + base + sblk->baz_blk.base, "%s_baz", >>> sspp_block->name); >>> >> >> Basically you are saying why not make the one line change here instead >> of using the name from the catalog. >> >> I think it will be better to use from the catalog for the reason I >> wrote above that dumping code should just "use" the catalog's >> information and not become a catalog itself. >> >> You are not saving much by dropping the sub-blk name from catalog anyway. >> >>> Moreover, if we follow the style of dpu_kms_mdp_snapshot() (which >>> doesn't use name), it should be: >>> >>> msm_disp_snapshot_add_block(disp_state, sblk->baz_blk.len, >>> mmio + base + sblk->baz_blk.base, "sspp%d_baz", >>> idx); >>> >>> >> tbh, after looking at this series, it made me think why I didnt use >> the name from the catalog even for the dpu_kms_mdp_snapshot() >>> >>>> >> >> <snipped> >
On 6/24/2023 7:44 PM, Abhinav Kumar wrote: > > > On 6/24/2023 8:03 AM, Dmitry Baryshkov wrote: >> On 24/06/2023 17:17, Abhinav Kumar wrote: >>> >>> >>> On 6/24/2023 5:07 AM, Dmitry Baryshkov wrote: >>>> On 24/06/2023 03:09, Abhinav Kumar wrote: >>>>> >>>>> >>>>> On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >>>>>> On 23/06/2023 02:48, Ryan McCann wrote: >>>>>>> Currently, the device core dump mechanism does not dump registers >>>>>>> of sub >>>>>>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>>>>>> function to dump hardware blocks that contain sub blocks. >>>>>>> >>>>>>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>>>>>> --- >>>>>>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>>>>>> +++++++++++++++++++++++++++----- >>>>>>> 1 file changed, 168 insertions(+), 26 deletions(-) >>>>>>> >>>>>>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>> index aa8499de1b9f..9b1b1c382269 100644 >>>>>>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct >>>>>>> msm_kms *kms) >>>>>>> return 0; >>>>>>> } >>>>>>> +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state >>>>>>> *disp_state, >>>>>>> + void __iomem *mmio, void *blk, >>>>>>> + enum dpu_hw_blk_type blk_type) >>>>>> >>>>>> No. Such multiplexers add no value to the code. Please inline it. >>>>>> >>>>>> Not to mention that this patch is hard to review. You both move >>>>>> existing code and add new features. If it were to go, it should >>>>>> have been split into two patches: one introducing the multiplexer >>>>>> and another one adding subblocks. >>>>>> >>>>> >>>>> Ok. we can split this into: >>>>> >>>>> 1) adding the multiplexer >>>>> 2) adding sub-blk parsing support inside the multiplexer >>>> >>>> I'd say, drop the multiplexer completely. It adds no value here. It >>>> is only used from dpu_kms_mdp_snapshot(). If the code there was >>>> complex enough, it would have made sense to _split_ the function. >>>> But even in such case there would be no point in having multiplexer. >>>> We do not enumerate block by type. >>>> >>> >>> Can you pls elaborate what you mean by enumerate blk by type? >>> >>> We do have DPU_HW_BLK_*** >>> >>> Did you mean sub-blk? >>> >>>>> >>>>>>> +{ >>>>>>> + u32 base; >>>>>>> + >>>>>>> + switch (blk_type) { >>>>>>> + case DPU_HW_BLK_TOP: >>>>>>> + { >>>>>>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>>>>>> + >>>>>>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>>>>>> + msm_disp_snapshot_add_block(disp_state, >>>>>>> MDP_PERIPH_TOP0, >>>>>>> + mmio + top->base, "top"); >>>>>>> + msm_disp_snapshot_add_block(disp_state, top->len - >>>>>>> MDP_PERIPH_TOP0_END, >>>>>>> + mmio + top->base + MDP_PERIPH_TOP0_END, >>>>>>> + "top_2"); >>>>>>> + } else { >>>>>>> + msm_disp_snapshot_add_block(disp_state, top->len, >>>>>>> mmio + top->base, "top"); >>>>>>> + } >>>>>>> + break; >>>>>>> + } >>>>>>> + case DPU_HW_BLK_LM: >>>>>>> + { >>>>>>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>>>>>> + >>>>>>> + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio >>>>>>> + mixer->base, "%s", >>>>>>> + mixer->name); >>>>>>> + break; >>>>>>> + } >>>>>>> + case DPU_HW_BLK_CTL: >>>>>>> + { >>>>>>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>>>>>> + >>>>>>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + >>>>>>> ctl->base, "%s", >>>>>>> + ctl->name); >>>>>>> + break; >>>>>>> + } >>>>>>> + case DPU_HW_BLK_INTF: >>>>>>> + { >>>>>>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>>>>>> + >>>>>>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio >>>>>>> + intf->base, "%s", >>>>>>> + intf->name); >>>>>>> + break; >>>>>>> + } >>>>>>> + case DPU_HW_BLK_WB: >>>>>>> + { >>>>>>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>>>>>> + >>>>>>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>>>>>> wb->base, "%s", >>>>>>> + wb->name); >>>>>>> + break; >>>>>>> + } >>>>>>> + case DPU_HW_BLK_SSPP: >>>>>>> + { >>>>>>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg >>>>>>> *)blk; >>>>>>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>>>>>> + >>>>>>> + base = sspp_block->base; >>>>>>> + >>>>>>> + msm_disp_snapshot_add_block(disp_state, sspp_block->len, >>>>>>> mmio + base, "%s", >>>>>>> + sspp_block->name); >>>>>>> + >>>>>>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>>>>>> + sspp_block->features & >>>>>>> BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>>>>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>>>>>> + msm_disp_snapshot_add_block(disp_state, >>>>>>> sblk->scaler_blk.len, >>>>>>> + mmio + base + sblk->scaler_blk.base, >>>>>>> "%s_%s", >>>>>>> + sspp_block->name, >>>>>>> sblk->scaler_blk.name); >>>>>> >>>>>> Actually, it would be better to: >>>>>> - drop name from all sblk instances (and use known string instead >>>>>> of the sblk name here) >>>>>> - Use sblk->foo_blk.len to check if it should be printed or not. >>>>>> >>>>> >>>>> No, I dont agree. If we drop the names from the sub_blk in the >>>>> catalog, we will end up using "sub_blk_name" string here in the >>>>> code to indicate which blk that is in the dump. >>>>> >>>>> If we add more sub_blks in the catalog in the future we need to >>>>> keep changing the code over here. Thats not how it should be. >>>>> >>>>> Leaving the names in the catalog ensures that this code wont change >>>>> and only catalog changes when we add a new sub_blk either for an >>>>> existing or new chipset. >>>>> >>>>> catalog is indicating the new blk, and dumping code just prints it. >>>>> >>>>> with your approach, dumping code will or can keep changing with >>>>> chipsets or sub_blks. Thats not how it should be. >>>> >>>> Well, we do not enumerate sub-blocks in any way, they are not >>>> indexed. So even with sblk->blk.name in place, adding new sub-block >>>> would require adding new code here. That's why I wrote that the >>>> calling code knows which sub-block it refers to. >>>> >>> >>> Today, unfortunately each sub_blk type is different so we have to do >>> this case by case. >>> >>> Ideally, this should have just been >>> >>> -> print main blk >>> -> print all sub-blks of the main blk >>> >>> Without having to handle each main blk's sub-blks separately. >>> >>> That way the dumping code would have remained generic without having >>> to do even the multiplexer in the first place. >>> >>> Need to explore if somehow we can come up with a generic sub-blk >>> struct and make this possible. Then this code will become much easier >>> and what I am saying will make total sense. >> >> In such case, yes. However I'd warn about having a generic array of >> subblocks. Having named subblock entries might complicate >> snapshotting, but it makes the rest of the DPU driver smaller. >> > > Need to explore this. But not immediately. > >>> >>> Even without that, conceptually these sub-blk names are reflecting >>> whats in our software document. So its not a random name but reflects >>> the actual sub-blk name from the hardware. >> >> Yes >> >>> So this belongs in the catalog. >> >> But the sub-block field already has a correct name: scaler_blk, >> csc_blk, etc. Having both sub-block field name and the .name inside >> results in kind of duplication, which seems unnecessary to me. >> > > No, there is a difference and not duplicated. One is the name of the > struct so it can really be anything and doesnt need to match the hw doc > name. But the other is the string name which we can give exactly to > match software interface doc and makes parsing such a dump much much > easier. > > One point I dont see you have considered is the block index of the sub_blk. > > Today, yes I see only a "pcc" or a "dither" etc > > What if there are two PCCs or two dithers. > > Then their names can just be "pcc_0" and "pcc_1" or "dither_0" and > "dither_1". > > Having name gives us the ability to easily incorporate even unsequential > indices. > > For example, every sspp's name today is not sequential. it can be > "sspp_3" then "sspp_8" etc > > By having names reflect the correct indices, dumping code becomes less > complex as the catalog will still have the right names as dumping code > will just use that. > The QC team is in agreement that we would like to go ahead with the names from the catalog and not drop them. Hence we will post the next revision with the name still from the catalog and drop the multiplexer completely. Since the intern has a short period of time to finish development on this task, we would like to go ahead with this approach and post the next rev.
On 30/06/2023 02:29, Abhinav Kumar wrote: > > > On 6/24/2023 7:44 PM, Abhinav Kumar wrote: >> >> >> On 6/24/2023 8:03 AM, Dmitry Baryshkov wrote: >>> On 24/06/2023 17:17, Abhinav Kumar wrote: >>>> >>>> >>>> On 6/24/2023 5:07 AM, Dmitry Baryshkov wrote: >>>>> On 24/06/2023 03:09, Abhinav Kumar wrote: >>>>>> >>>>>> >>>>>> On 6/22/2023 5:13 PM, Dmitry Baryshkov wrote: >>>>>>> On 23/06/2023 02:48, Ryan McCann wrote: >>>>>>>> Currently, the device core dump mechanism does not dump >>>>>>>> registers of sub >>>>>>>> blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper >>>>>>>> function to dump hardware blocks that contain sub blocks. >>>>>>>> >>>>>>>> Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> >>>>>>>> --- >>>>>>>> drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 >>>>>>>> +++++++++++++++++++++++++++----- >>>>>>>> 1 file changed, 168 insertions(+), 26 deletions(-) >>>>>>>> >>>>>>>> diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>>> b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>>> index aa8499de1b9f..9b1b1c382269 100644 >>>>>>>> --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>>> +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c >>>>>>>> @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct >>>>>>>> msm_kms *kms) >>>>>>>> return 0; >>>>>>>> } >>>>>>>> +static void dpu_kms_mdp_snapshot_add_block(struct >>>>>>>> msm_disp_state *disp_state, >>>>>>>> + void __iomem *mmio, void *blk, >>>>>>>> + enum dpu_hw_blk_type blk_type) >>>>>>> >>>>>>> No. Such multiplexers add no value to the code. Please inline it. >>>>>>> >>>>>>> Not to mention that this patch is hard to review. You both move >>>>>>> existing code and add new features. If it were to go, it should >>>>>>> have been split into two patches: one introducing the multiplexer >>>>>>> and another one adding subblocks. >>>>>>> >>>>>> >>>>>> Ok. we can split this into: >>>>>> >>>>>> 1) adding the multiplexer >>>>>> 2) adding sub-blk parsing support inside the multiplexer >>>>> >>>>> I'd say, drop the multiplexer completely. It adds no value here. It >>>>> is only used from dpu_kms_mdp_snapshot(). If the code there was >>>>> complex enough, it would have made sense to _split_ the function. >>>>> But even in such case there would be no point in having >>>>> multiplexer. We do not enumerate block by type. >>>>> >>>> >>>> Can you pls elaborate what you mean by enumerate blk by type? >>>> >>>> We do have DPU_HW_BLK_*** >>>> >>>> Did you mean sub-blk? >>>> >>>>>> >>>>>>>> +{ >>>>>>>> + u32 base; >>>>>>>> + >>>>>>>> + switch (blk_type) { >>>>>>>> + case DPU_HW_BLK_TOP: >>>>>>>> + { >>>>>>>> + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; >>>>>>>> + >>>>>>>> + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { >>>>>>>> + msm_disp_snapshot_add_block(disp_state, >>>>>>>> MDP_PERIPH_TOP0, >>>>>>>> + mmio + top->base, "top"); >>>>>>>> + msm_disp_snapshot_add_block(disp_state, top->len - >>>>>>>> MDP_PERIPH_TOP0_END, >>>>>>>> + mmio + top->base + >>>>>>>> MDP_PERIPH_TOP0_END, >>>>>>>> + "top_2"); >>>>>>>> + } else { >>>>>>>> + msm_disp_snapshot_add_block(disp_state, top->len, >>>>>>>> mmio + top->base, "top"); >>>>>>>> + } >>>>>>>> + break; >>>>>>>> + } >>>>>>>> + case DPU_HW_BLK_LM: >>>>>>>> + { >>>>>>>> + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; >>>>>>>> + >>>>>>>> + msm_disp_snapshot_add_block(disp_state, mixer->len, >>>>>>>> mmio + mixer->base, "%s", >>>>>>>> + mixer->name); >>>>>>>> + break; >>>>>>>> + } >>>>>>>> + case DPU_HW_BLK_CTL: >>>>>>>> + { >>>>>>>> + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; >>>>>>>> + >>>>>>>> + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio >>>>>>>> + ctl->base, "%s", >>>>>>>> + ctl->name); >>>>>>>> + break; >>>>>>>> + } >>>>>>>> + case DPU_HW_BLK_INTF: >>>>>>>> + { >>>>>>>> + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; >>>>>>>> + >>>>>>>> + msm_disp_snapshot_add_block(disp_state, intf->len, mmio >>>>>>>> + intf->base, "%s", >>>>>>>> + intf->name); >>>>>>>> + break; >>>>>>>> + } >>>>>>>> + case DPU_HW_BLK_WB: >>>>>>>> + { >>>>>>>> + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; >>>>>>>> + >>>>>>>> + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + >>>>>>>> wb->base, "%s", >>>>>>>> + wb->name); >>>>>>>> + break; >>>>>>>> + } >>>>>>>> + case DPU_HW_BLK_SSPP: >>>>>>>> + { >>>>>>>> + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg >>>>>>>> *)blk; >>>>>>>> + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; >>>>>>>> + >>>>>>>> + base = sspp_block->base; >>>>>>>> + >>>>>>>> + msm_disp_snapshot_add_block(disp_state, >>>>>>>> sspp_block->len, mmio + base, "%s", >>>>>>>> + sspp_block->name); >>>>>>>> + >>>>>>>> + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || >>>>>>>> + sspp_block->features & >>>>>>>> BIT(DPU_SSPP_SCALER_QSEED3LITE) || >>>>>>>> + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) >>>>>>>> + msm_disp_snapshot_add_block(disp_state, >>>>>>>> sblk->scaler_blk.len, >>>>>>>> + mmio + base + >>>>>>>> sblk->scaler_blk.base, "%s_%s", >>>>>>>> + sspp_block->name, >>>>>>>> sblk->scaler_blk.name); >>>>>>> >>>>>>> Actually, it would be better to: >>>>>>> - drop name from all sblk instances (and use known string instead >>>>>>> of the sblk name here) >>>>>>> - Use sblk->foo_blk.len to check if it should be printed or not. >>>>>>> >>>>>> >>>>>> No, I dont agree. If we drop the names from the sub_blk in the >>>>>> catalog, we will end up using "sub_blk_name" string here in the >>>>>> code to indicate which blk that is in the dump. >>>>>> >>>>>> If we add more sub_blks in the catalog in the future we need to >>>>>> keep changing the code over here. Thats not how it should be. >>>>>> >>>>>> Leaving the names in the catalog ensures that this code wont >>>>>> change and only catalog changes when we add a new sub_blk either >>>>>> for an existing or new chipset. >>>>>> >>>>>> catalog is indicating the new blk, and dumping code just prints it. >>>>>> >>>>>> with your approach, dumping code will or can keep changing with >>>>>> chipsets or sub_blks. Thats not how it should be. >>>>> >>>>> Well, we do not enumerate sub-blocks in any way, they are not >>>>> indexed. So even with sblk->blk.name in place, adding new sub-block >>>>> would require adding new code here. That's why I wrote that the >>>>> calling code knows which sub-block it refers to. >>>>> >>>> >>>> Today, unfortunately each sub_blk type is different so we have to do >>>> this case by case. >>>> >>>> Ideally, this should have just been >>>> >>>> -> print main blk >>>> -> print all sub-blks of the main blk >>>> >>>> Without having to handle each main blk's sub-blks separately. >>>> >>>> That way the dumping code would have remained generic without having >>>> to do even the multiplexer in the first place. >>>> >>>> Need to explore if somehow we can come up with a generic sub-blk >>>> struct and make this possible. Then this code will become much >>>> easier and what I am saying will make total sense. >>> >>> In such case, yes. However I'd warn about having a generic array of >>> subblocks. Having named subblock entries might complicate >>> snapshotting, but it makes the rest of the DPU driver smaller. >>> >> >> Need to explore this. But not immediately. >> >>>> >>>> Even without that, conceptually these sub-blk names are reflecting >>>> whats in our software document. So its not a random name but >>>> reflects the actual sub-blk name from the hardware. >>> >>> Yes >>> >>>> So this belongs in the catalog. >>> >>> But the sub-block field already has a correct name: scaler_blk, >>> csc_blk, etc. Having both sub-block field name and the .name inside >>> results in kind of duplication, which seems unnecessary to me. >>> >> >> No, there is a difference and not duplicated. One is the name of the >> struct so it can really be anything and doesnt need to match the hw >> doc name. But the other is the string name which we can give exactly >> to match software interface doc and makes parsing such a dump much >> much easier. >> >> One point I dont see you have considered is the block index of the >> sub_blk. >> >> Today, yes I see only a "pcc" or a "dither" etc >> >> What if there are two PCCs or two dithers. >> >> Then their names can just be "pcc_0" and "pcc_1" or "dither_0" and >> "dither_1". >> >> Having name gives us the ability to easily incorporate even >> unsequential indices. >> >> For example, every sspp's name today is not sequential. it can be >> "sspp_3" then "sspp_8" etc >> >> By having names reflect the correct indices, dumping code becomes less >> complex as the catalog will still have the right names as dumping code >> will just use that. >> > > The QC team is in agreement that we would like to go ahead with the > names from the catalog and not drop them. > > Hence we will post the next revision with the name still from the > catalog and drop the multiplexer completely. Ack, let's see how it goes. > > Since the intern has a short period of time to finish development on > this task, we would like to go ahead with this approach and post the > next rev. This is a bad argument.
diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c index aa8499de1b9f..9b1b1c382269 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c @@ -885,6 +885,154 @@ static int dpu_irq_postinstall(struct msm_kms *kms) return 0; } +static void dpu_kms_mdp_snapshot_add_block(struct msm_disp_state *disp_state, + void __iomem *mmio, void *blk, + enum dpu_hw_blk_type blk_type) +{ + u32 base; + + switch (blk_type) { + case DPU_HW_BLK_TOP: + { + struct dpu_mdp_cfg *top = (struct dpu_mdp_cfg *)blk; + + if (top->features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { + msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, + mmio + top->base, "top"); + msm_disp_snapshot_add_block(disp_state, top->len - MDP_PERIPH_TOP0_END, + mmio + top->base + MDP_PERIPH_TOP0_END, + "top_2"); + } else { + msm_disp_snapshot_add_block(disp_state, top->len, mmio + top->base, "top"); + } + break; + } + case DPU_HW_BLK_LM: + { + struct dpu_lm_cfg *mixer = (struct dpu_lm_cfg *)blk; + + msm_disp_snapshot_add_block(disp_state, mixer->len, mmio + mixer->base, "%s", + mixer->name); + break; + } + case DPU_HW_BLK_CTL: + { + struct dpu_ctl_cfg *ctl = (struct dpu_ctl_cfg *)blk; + + msm_disp_snapshot_add_block(disp_state, ctl->len, mmio + ctl->base, "%s", + ctl->name); + break; + } + case DPU_HW_BLK_INTF: + { + struct dpu_intf_cfg *intf = (struct dpu_intf_cfg *)blk; + + msm_disp_snapshot_add_block(disp_state, intf->len, mmio + intf->base, "%s", + intf->name); + break; + } + case DPU_HW_BLK_WB: + { + struct dpu_wb_cfg *wb = (struct dpu_wb_cfg *)blk; + + msm_disp_snapshot_add_block(disp_state, wb->len, mmio + wb->base, "%s", + wb->name); + break; + } + case DPU_HW_BLK_SSPP: + { + struct dpu_sspp_cfg *sspp_block = (struct dpu_sspp_cfg *)blk; + const struct dpu_sspp_sub_blks *sblk = sspp_block->sblk; + + base = sspp_block->base; + + msm_disp_snapshot_add_block(disp_state, sspp_block->len, mmio + base, "%s", + sspp_block->name); + + if (sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3) || + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED3LITE) || + sspp_block->features & BIT(DPU_SSPP_SCALER_QSEED4)) + msm_disp_snapshot_add_block(disp_state, sblk->scaler_blk.len, + mmio + base + sblk->scaler_blk.base, "%s_%s", + sspp_block->name, sblk->scaler_blk.name); + + if (sspp_block->features & BIT(DPU_SSPP_CSC) || sspp_block->features + & BIT(DPU_SSPP_CSC_10BIT)) + msm_disp_snapshot_add_block(disp_state, sblk->csc_blk.len, + mmio + base + sblk->csc_blk.base, "%s_%s", + sspp_block->name, sblk->csc_blk.name); + break; + } + case DPU_HW_BLK_DSPP: + { + struct dpu_dspp_cfg *dspp_block = (struct dpu_dspp_cfg *)blk; + + base = dspp_block->base; + + msm_disp_snapshot_add_block(disp_state, dspp_block->len, mmio + base, "%s", + dspp_block->name); + + if (dspp_block->features & BIT(DPU_DSPP_PCC)) + msm_disp_snapshot_add_block(disp_state, dspp_block->sblk->pcc.len, + mmio + base + dspp_block->sblk->pcc.base, + "%s_%s", dspp_block->name, + dspp_block->sblk->pcc.name); + break; + } + case DPU_HW_BLK_PINGPONG: + { + struct dpu_pingpong_cfg *pingpong_block = (struct dpu_pingpong_cfg *)blk; + const struct dpu_pingpong_sub_blks *sblk = pingpong_block->sblk; + + base = pingpong_block->base; + + msm_disp_snapshot_add_block(disp_state, pingpong_block->len, mmio + base, "%s", + pingpong_block->name); + + if (pingpong_block->features & BIT(DPU_PINGPONG_TE2)) + msm_disp_snapshot_add_block(disp_state, sblk->te2.len, + mmio + base + sblk->te2.base, "%s_%s", + pingpong_block->name, sblk->te2.name); + + if (pingpong_block->features & BIT(DPU_PINGPONG_DITHER)) + msm_disp_snapshot_add_block(disp_state, sblk->dither.len, + mmio + base + sblk->dither.base, "%s_%s", + pingpong_block->name, sblk->dither.name); + break; + } + case DPU_HW_BLK_DSC: + { + struct dpu_dsc_cfg *dsc_block = (struct dpu_dsc_cfg *)blk; + + base = dsc_block->base; + + if (dsc_block->features & BIT(DPU_DSC_HW_REV_1_2)) { + struct dpu_dsc_blk enc = dsc_block->sblk->enc; + struct dpu_dsc_blk ctl = dsc_block->sblk->ctl; + + /* For now, pass in a length of 0 because the DSC_BLK register space + * overlaps with the sblks' register space. + * + * TODO: Pass in a length of 0 t0 DSC_BLK_1_2 in the HW catalog where + * applicable. + */ + msm_disp_snapshot_add_block(disp_state, 0, mmio + base, "%s", + dsc_block->name); + msm_disp_snapshot_add_block(disp_state, enc.len, mmio + base + enc.base, + "%s_%s", dsc_block->name, enc.name); + msm_disp_snapshot_add_block(disp_state, ctl.len, mmio + base + ctl.base, + "%s_%s", dsc_block->name, ctl.name); + } else { + msm_disp_snapshot_add_block(disp_state, dsc_block->len, mmio + base, "%s", + dsc_block->name); + } + break; + } + default: + DPU_ERROR("Block type not supported."); + } +} + static void dpu_kms_mdp_snapshot(struct msm_disp_state *disp_state, struct msm_kms *kms) { int i; @@ -899,53 +1047,47 @@ static void dpu_kms_mdp_snapshot(struct msm_disp_state *disp_state, struct msm_k /* dump CTL sub-blocks HW regs info */ for (i = 0; i < cat->ctl_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->ctl[i].len, - dpu_kms->mmio + cat->ctl[i].base, "ctl_%d", i); + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->ctl[i], + DPU_HW_BLK_CTL); /* dump DSPP sub-blocks HW regs info */ for (i = 0; i < cat->dspp_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->dspp[i].len, - dpu_kms->mmio + cat->dspp[i].base, "dspp_%d", i); + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->dspp[i], + DPU_HW_BLK_DSPP); /* dump INTF sub-blocks HW regs info */ for (i = 0; i < cat->intf_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->intf[i].len, - dpu_kms->mmio + cat->intf[i].base, "intf_%d", i); + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->intf[i], + DPU_HW_BLK_INTF); /* dump PP sub-blocks HW regs info */ for (i = 0; i < cat->pingpong_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->pingpong[i].len, - dpu_kms->mmio + cat->pingpong[i].base, "pingpong_%d", i); + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->pingpong[i], + DPU_HW_BLK_PINGPONG); /* dump SSPP sub-blocks HW regs info */ for (i = 0; i < cat->sspp_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->sspp[i].len, - dpu_kms->mmio + cat->sspp[i].base, "sspp_%d", i); + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->sspp[i], + DPU_HW_BLK_SSPP); /* dump LM sub-blocks HW regs info */ for (i = 0; i < cat->mixer_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->mixer[i].len, - dpu_kms->mmio + cat->mixer[i].base, "lm_%d", i); + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->mixer[i], + DPU_HW_BLK_LM); /* dump WB sub-blocks HW regs info */ for (i = 0; i < cat->wb_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->wb[i].len, - dpu_kms->mmio + cat->wb[i].base, "wb_%d", i); - - if (cat->mdp[0].features & BIT(DPU_MDP_PERIPH_0_REMOVED)) { - msm_disp_snapshot_add_block(disp_state, MDP_PERIPH_TOP0, - dpu_kms->mmio + cat->mdp[0].base, "top"); - msm_disp_snapshot_add_block(disp_state, cat->mdp[0].len - MDP_PERIPH_TOP0_END, - dpu_kms->mmio + cat->mdp[0].base + MDP_PERIPH_TOP0_END, "top_2"); - } else { - msm_disp_snapshot_add_block(disp_state, cat->mdp[0].len, - dpu_kms->mmio + cat->mdp[0].base, "top"); - } + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->wb[i], + DPU_HW_BLK_WB); + + /* dump top block */ + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->mdp[0], + DPU_HW_BLK_TOP); /* dump DSC sub-blocks HW regs info */ for (i = 0; i < cat->dsc_count; i++) - msm_disp_snapshot_add_block(disp_state, cat->dsc[i].len, - dpu_kms->mmio + cat->dsc[i].base, "dsc_%d", i); + dpu_kms_mdp_snapshot_add_block(disp_state, dpu_kms->mmio, (void *)&cat->dsc[i], + DPU_HW_BLK_DSC); pm_runtime_put_sync(&dpu_kms->pdev->dev); }
Currently, the device core dump mechanism does not dump registers of sub blocks within the DSPP, SSPP, DSC, and PINGPONG blocks. Add wrapper function to dump hardware blocks that contain sub blocks. Signed-off-by: Ryan McCann <quic_rmccann@quicinc.com> --- drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 194 +++++++++++++++++++++++++++----- 1 file changed, 168 insertions(+), 26 deletions(-)