1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved. 4 */ 5 6 #define pr_fmt(fmt) "[drm:%s:%d] " fmt, __func__, __LINE__ 7 8 #include <generated/utsrelease.h> 9 10 #include "msm_disp_snapshot.h" 11 12 static void msm_disp_state_dump_regs(u32 **reg, u32 aligned_len, void __iomem *base_addr) 13 { 14 u32 len_padded; 15 u32 num_rows; 16 u32 x0, x4, x8, xc; 17 void __iomem *addr; 18 u32 *dump_addr = NULL; 19 void __iomem *end_addr; 20 int i; 21 22 len_padded = aligned_len * REG_DUMP_ALIGN; 23 num_rows = aligned_len / REG_DUMP_ALIGN; 24 25 addr = base_addr; 26 end_addr = base_addr + aligned_len; 27 28 if (!(*reg)) 29 *reg = kzalloc(len_padded, GFP_KERNEL); 30 31 if (*reg) 32 dump_addr = *reg; 33 34 for (i = 0; i < num_rows; i++) { 35 x0 = (addr < end_addr) ? readl_relaxed(addr + 0x0) : 0; 36 x4 = (addr + 0x4 < end_addr) ? readl_relaxed(addr + 0x4) : 0; 37 x8 = (addr + 0x8 < end_addr) ? readl_relaxed(addr + 0x8) : 0; 38 xc = (addr + 0xc < end_addr) ? readl_relaxed(addr + 0xc) : 0; 39 40 if (dump_addr) { 41 dump_addr[i * 4] = x0; 42 dump_addr[i * 4 + 1] = x4; 43 dump_addr[i * 4 + 2] = x8; 44 dump_addr[i * 4 + 3] = xc; 45 } 46 47 addr += REG_DUMP_ALIGN; 48 } 49 } 50 51 static void msm_disp_state_print_regs(u32 **reg, u32 len, void __iomem *base_addr, 52 struct drm_printer *p) 53 { 54 int i; 55 u32 *dump_addr = NULL; 56 void __iomem *addr; 57 u32 num_rows; 58 59 addr = base_addr; 60 num_rows = len / REG_DUMP_ALIGN; 61 62 if (*reg) 63 dump_addr = *reg; 64 65 for (i = 0; i < num_rows; i++) { 66 drm_printf(p, "0x%lx : %08x %08x %08x %08x\n", 67 (unsigned long)(addr - base_addr), 68 dump_addr[i * 4], dump_addr[i * 4 + 1], 69 dump_addr[i * 4 + 2], dump_addr[i * 4 + 3]); 70 addr += REG_DUMP_ALIGN; 71 } 72 } 73 74 void msm_disp_state_print(struct msm_disp_state *state, struct drm_printer *p) 75 { 76 struct msm_disp_state_block *block, *tmp; 77 78 if (!p) { 79 DRM_ERROR("invalid drm printer\n"); 80 return; 81 } 82 83 drm_printf(p, "---\n"); 84 drm_printf(p, "kernel: " UTS_RELEASE "\n"); 85 drm_printf(p, "module: " KBUILD_MODNAME "\n"); 86 drm_printf(p, "dpu devcoredump\n"); 87 drm_printf(p, "time: %lld.%09ld\n", 88 state->time.tv_sec, state->time.tv_nsec); 89 90 list_for_each_entry_safe(block, tmp, &state->blocks, node) { 91 drm_printf(p, "====================%s================\n", block->name); 92 msm_disp_state_print_regs(&block->state, block->size, block->base_addr, p); 93 } 94 95 drm_printf(p, "===================dpu drm state================\n"); 96 97 if (state->atomic_state) 98 drm_atomic_print_new_state(state->atomic_state, p); 99 } 100 101 static void msm_disp_capture_atomic_state(struct msm_disp_state *disp_state) 102 { 103 struct drm_device *ddev; 104 struct drm_modeset_acquire_ctx ctx; 105 106 ktime_get_real_ts64(&disp_state->time); 107 108 ddev = disp_state->drm_dev; 109 110 drm_modeset_acquire_init(&ctx, 0); 111 112 while (drm_modeset_lock_all_ctx(ddev, &ctx) != 0) 113 drm_modeset_backoff(&ctx); 114 115 disp_state->atomic_state = drm_atomic_helper_duplicate_state(ddev, 116 &ctx); 117 drm_modeset_drop_locks(&ctx); 118 drm_modeset_acquire_fini(&ctx); 119 } 120 121 void msm_disp_snapshot_capture_state(struct msm_disp_state *disp_state) 122 { 123 struct msm_drm_private *priv; 124 struct drm_device *drm_dev; 125 struct msm_kms *kms; 126 int i; 127 128 drm_dev = disp_state->drm_dev; 129 priv = drm_dev->dev_private; 130 kms = priv->kms; 131 132 for (i = 0; i < ARRAY_SIZE(priv->dp); i++) { 133 if (!priv->dp[i]) 134 continue; 135 136 msm_dp_snapshot(disp_state, priv->dp[i]); 137 } 138 139 for (i = 0; i < ARRAY_SIZE(priv->dsi); i++) { 140 if (!priv->dsi[i]) 141 continue; 142 143 msm_dsi_snapshot(disp_state, priv->dsi[i]); 144 } 145 146 if (kms->funcs->snapshot) 147 kms->funcs->snapshot(disp_state, kms); 148 149 msm_disp_capture_atomic_state(disp_state); 150 } 151 152 void msm_disp_state_free(void *data) 153 { 154 struct msm_disp_state *disp_state = data; 155 struct msm_disp_state_block *block, *tmp; 156 157 if (disp_state->atomic_state) { 158 drm_atomic_state_put(disp_state->atomic_state); 159 disp_state->atomic_state = NULL; 160 } 161 162 list_for_each_entry_safe(block, tmp, &disp_state->blocks, node) { 163 list_del(&block->node); 164 kfree(block->state); 165 kfree(block); 166 } 167 168 kfree(disp_state); 169 } 170 171 void msm_disp_snapshot_add_block(struct msm_disp_state *disp_state, u32 len, 172 void __iomem *base_addr, const char *fmt, ...) 173 { 174 struct msm_disp_state_block *new_blk; 175 struct va_format vaf; 176 va_list va; 177 178 new_blk = kzalloc(sizeof(struct msm_disp_state_block), GFP_KERNEL); 179 if (!new_blk) 180 return; 181 182 va_start(va, fmt); 183 184 vaf.fmt = fmt; 185 vaf.va = &va; 186 snprintf(new_blk->name, sizeof(new_blk->name), "%pV", &vaf); 187 188 va_end(va); 189 190 INIT_LIST_HEAD(&new_blk->node); 191 new_blk->size = ALIGN(len, REG_DUMP_ALIGN); 192 new_blk->base_addr = base_addr; 193 194 msm_disp_state_dump_regs(&new_blk->state, new_blk->size, base_addr); 195 list_add(&new_blk->node, &disp_state->blocks); 196 } 197