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 = kvzalloc(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(const u32 *dump_addr, u32 len, 52 void __iomem *base_addr, struct drm_printer *p) 53 { 54 int i; 55 void __iomem *addr; 56 u32 num_rows; 57 58 if (!dump_addr) { 59 drm_printf(p, "Registers not stored\n"); 60 return; 61 } 62 63 addr = base_addr; 64 num_rows = len / REG_DUMP_ALIGN; 65 66 for (i = 0; i < num_rows; i++) { 67 drm_printf(p, "0x%lx : %08x %08x %08x %08x\n", 68 (unsigned long)(addr - base_addr), 69 dump_addr[i * 4], dump_addr[i * 4 + 1], 70 dump_addr[i * 4 + 2], dump_addr[i * 4 + 3]); 71 addr += REG_DUMP_ALIGN; 72 } 73 } 74 75 void msm_disp_state_print(struct msm_disp_state *state, struct drm_printer *p) 76 { 77 struct msm_disp_state_block *block, *tmp; 78 79 if (!p) { 80 DRM_ERROR("invalid drm printer\n"); 81 return; 82 } 83 84 drm_printf(p, "---\n"); 85 drm_printf(p, "kernel: " UTS_RELEASE "\n"); 86 drm_printf(p, "module: " KBUILD_MODNAME "\n"); 87 drm_printf(p, "dpu devcoredump\n"); 88 drm_printf(p, "time: %lld.%09ld\n", 89 state->time.tv_sec, state->time.tv_nsec); 90 91 list_for_each_entry_safe(block, tmp, &state->blocks, node) { 92 drm_printf(p, "====================%s================\n", block->name); 93 msm_disp_state_print_regs(block->state, block->size, block->base_addr, p); 94 } 95 96 drm_printf(p, "===================dpu drm state================\n"); 97 98 if (state->atomic_state) 99 drm_atomic_print_new_state(state->atomic_state, p); 100 } 101 102 static void msm_disp_capture_atomic_state(struct msm_disp_state *disp_state) 103 { 104 struct drm_device *ddev; 105 struct drm_modeset_acquire_ctx ctx; 106 107 ktime_get_real_ts64(&disp_state->time); 108 109 ddev = disp_state->drm_dev; 110 111 drm_modeset_acquire_init(&ctx, 0); 112 113 while (drm_modeset_lock_all_ctx(ddev, &ctx) != 0) 114 drm_modeset_backoff(&ctx); 115 116 disp_state->atomic_state = drm_atomic_helper_duplicate_state(ddev, 117 &ctx); 118 drm_modeset_drop_locks(&ctx); 119 drm_modeset_acquire_fini(&ctx); 120 } 121 122 void msm_disp_snapshot_capture_state(struct msm_disp_state *disp_state) 123 { 124 struct msm_drm_private *priv; 125 struct drm_device *drm_dev; 126 struct msm_kms *kms; 127 int i; 128 129 drm_dev = disp_state->drm_dev; 130 priv = drm_dev->dev_private; 131 kms = priv->kms; 132 133 for (i = 0; i < ARRAY_SIZE(priv->dp); i++) { 134 if (!priv->dp[i]) 135 continue; 136 137 msm_dp_snapshot(disp_state, priv->dp[i]); 138 } 139 140 for (i = 0; i < ARRAY_SIZE(priv->dsi); i++) { 141 if (!priv->dsi[i]) 142 continue; 143 144 msm_dsi_snapshot(disp_state, priv->dsi[i]); 145 } 146 147 if (kms->funcs->snapshot) 148 kms->funcs->snapshot(disp_state, kms); 149 150 msm_disp_capture_atomic_state(disp_state); 151 } 152 153 void msm_disp_state_free(void *data) 154 { 155 struct msm_disp_state *disp_state = data; 156 struct msm_disp_state_block *block, *tmp; 157 158 if (disp_state->atomic_state) { 159 drm_atomic_state_put(disp_state->atomic_state); 160 disp_state->atomic_state = NULL; 161 } 162 163 list_for_each_entry_safe(block, tmp, &disp_state->blocks, node) { 164 list_del(&block->node); 165 kvfree(block->state); 166 kfree(block); 167 } 168 169 kfree(disp_state); 170 } 171 172 void msm_disp_snapshot_add_block(struct msm_disp_state *disp_state, u32 len, 173 void __iomem *base_addr, const char *fmt, ...) 174 { 175 struct msm_disp_state_block *new_blk; 176 struct va_format vaf; 177 va_list va; 178 179 new_blk = kzalloc(sizeof(struct msm_disp_state_block), GFP_KERNEL); 180 if (!new_blk) 181 return; 182 183 va_start(va, fmt); 184 185 vaf.fmt = fmt; 186 vaf.va = &va; 187 snprintf(new_blk->name, sizeof(new_blk->name), "%pV", &vaf); 188 189 va_end(va); 190 191 INIT_LIST_HEAD(&new_blk->node); 192 new_blk->size = ALIGN(len, REG_DUMP_ALIGN); 193 new_blk->base_addr = base_addr; 194 195 msm_disp_state_dump_regs(&new_blk->state, new_blk->size, base_addr); 196 list_add_tail(&new_blk->node, &disp_state->blocks); 197 } 198