1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) STMicroelectronics SA 2015 4 * Authors: Yannick Fertre <yannick.fertre@st.com> 5 * Hugues Fruchet <hugues.fruchet@st.com> 6 */ 7 8 #include <linux/debugfs.h> 9 10 #include "hva.h" 11 #include "hva-hw.h" 12 13 static void format_ctx(struct seq_file *s, struct hva_ctx *ctx) 14 { 15 struct hva_streaminfo *stream = &ctx->streaminfo; 16 struct hva_frameinfo *frame = &ctx->frameinfo; 17 struct hva_controls *ctrls = &ctx->ctrls; 18 struct hva_ctx_dbg *dbg = &ctx->dbg; 19 u32 bitrate_mode, aspect, entropy, vui_sar, sei_fp; 20 21 seq_printf(s, "|-%s\n |\n", ctx->name); 22 23 seq_printf(s, " |-[%sframe info]\n", 24 ctx->flags & HVA_FLAG_FRAMEINFO ? "" : "default "); 25 seq_printf(s, " | |- pixel format=%4.4s\n" 26 " | |- wxh=%dx%d\n" 27 " | |- wxh (w/ encoder alignment constraint)=%dx%d\n" 28 " |\n", 29 (char *)&frame->pixelformat, 30 frame->width, frame->height, 31 frame->aligned_width, frame->aligned_height); 32 33 seq_printf(s, " |-[%sstream info]\n", 34 ctx->flags & HVA_FLAG_STREAMINFO ? "" : "default "); 35 seq_printf(s, " | |- stream format=%4.4s\n" 36 " | |- wxh=%dx%d\n" 37 " | |- %s\n" 38 " | |- %s\n" 39 " |\n", 40 (char *)&stream->streamformat, 41 stream->width, stream->height, 42 stream->profile, stream->level); 43 44 bitrate_mode = V4L2_CID_MPEG_VIDEO_BITRATE_MODE; 45 aspect = V4L2_CID_MPEG_VIDEO_ASPECT; 46 seq_puts(s, " |-[parameters]\n"); 47 seq_printf(s, " | |- %s\n" 48 " | |- bitrate=%d bps\n" 49 " | |- GOP size=%d\n" 50 " | |- video aspect=%s\n" 51 " | |- framerate=%d/%d\n", 52 v4l2_ctrl_get_menu(bitrate_mode)[ctrls->bitrate_mode], 53 ctrls->bitrate, 54 ctrls->gop_size, 55 v4l2_ctrl_get_menu(aspect)[ctrls->aspect], 56 ctrls->time_per_frame.denominator, 57 ctrls->time_per_frame.numerator); 58 59 entropy = V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE; 60 vui_sar = V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC; 61 sei_fp = V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE; 62 if (stream->streamformat == V4L2_PIX_FMT_H264) { 63 seq_printf(s, " | |- %s entropy mode\n" 64 " | |- CPB size=%d kB\n" 65 " | |- DCT8x8 enable=%s\n" 66 " | |- qpmin=%d\n" 67 " | |- qpmax=%d\n" 68 " | |- PAR enable=%s\n" 69 " | |- PAR id=%s\n" 70 " | |- SEI frame packing enable=%s\n" 71 " | |- SEI frame packing type=%s\n", 72 v4l2_ctrl_get_menu(entropy)[ctrls->entropy_mode], 73 ctrls->cpb_size, 74 ctrls->dct8x8 ? "true" : "false", 75 ctrls->qpmin, 76 ctrls->qpmax, 77 ctrls->vui_sar ? "true" : "false", 78 v4l2_ctrl_get_menu(vui_sar)[ctrls->vui_sar_idc], 79 ctrls->sei_fp ? "true" : "false", 80 v4l2_ctrl_get_menu(sei_fp)[ctrls->sei_fp_type]); 81 } 82 83 if (ctx->sys_errors || ctx->encode_errors || ctx->frame_errors) { 84 seq_puts(s, " |\n |-[errors]\n"); 85 seq_printf(s, " | |- system=%d\n" 86 " | |- encoding=%d\n" 87 " | |- frame=%d\n", 88 ctx->sys_errors, 89 ctx->encode_errors, 90 ctx->frame_errors); 91 } 92 93 seq_puts(s, " |\n |-[performances]\n"); 94 seq_printf(s, " | |- frames encoded=%d\n" 95 " | |- avg HW processing duration (0.1ms)=%d [min=%d, max=%d]\n" 96 " | |- avg encoding period (0.1ms)=%d [min=%d, max=%d]\n" 97 " | |- avg fps (0.1Hz)=%d\n" 98 " | |- max reachable fps (0.1Hz)=%d\n" 99 " | |- avg bitrate (kbps)=%d [min=%d, max=%d]\n" 100 " | |- last bitrate (kbps)=%d\n", 101 dbg->cnt_duration, 102 dbg->avg_duration, 103 dbg->min_duration, 104 dbg->max_duration, 105 dbg->avg_period, 106 dbg->min_period, 107 dbg->max_period, 108 dbg->avg_fps, 109 dbg->max_fps, 110 dbg->avg_bitrate, 111 dbg->min_bitrate, 112 dbg->max_bitrate, 113 dbg->last_bitrate); 114 } 115 116 /* 117 * performance debug info 118 */ 119 void hva_dbg_perf_begin(struct hva_ctx *ctx) 120 { 121 u64 div; 122 u32 period; 123 u32 bitrate; 124 struct hva_ctx_dbg *dbg = &ctx->dbg; 125 ktime_t prev = dbg->begin; 126 127 dbg->begin = ktime_get(); 128 129 if (dbg->is_valid_period) { 130 /* encoding period */ 131 div = (u64)ktime_us_delta(dbg->begin, prev); 132 do_div(div, 100); 133 period = (u32)div; 134 dbg->min_period = min(period, dbg->min_period); 135 dbg->max_period = max(period, dbg->max_period); 136 dbg->total_period += period; 137 dbg->cnt_period++; 138 139 /* 140 * minimum and maximum bitrates are based on the 141 * encoding period values upon a window of 32 samples 142 */ 143 dbg->window_duration += period; 144 dbg->cnt_window++; 145 if (dbg->cnt_window >= 32) { 146 /* 147 * bitrate in kbps = (size * 8 / 1000) / 148 * (duration / 10000) 149 * = size * 80 / duration 150 */ 151 if (dbg->window_duration > 0) { 152 div = (u64)dbg->window_stream_size * 80; 153 do_div(div, dbg->window_duration); 154 bitrate = (u32)div; 155 dbg->last_bitrate = bitrate; 156 dbg->min_bitrate = min(bitrate, 157 dbg->min_bitrate); 158 dbg->max_bitrate = max(bitrate, 159 dbg->max_bitrate); 160 } 161 dbg->window_stream_size = 0; 162 dbg->window_duration = 0; 163 dbg->cnt_window = 0; 164 } 165 } 166 167 /* 168 * filter sequences valid for performance: 169 * - begin/begin (no stream available) is an invalid sequence 170 * - begin/end is a valid sequence 171 */ 172 dbg->is_valid_period = false; 173 } 174 175 void hva_dbg_perf_end(struct hva_ctx *ctx, struct hva_stream *stream) 176 { 177 struct device *dev = ctx_to_dev(ctx); 178 u64 div; 179 u32 duration; 180 u32 bytesused; 181 u32 timestamp; 182 struct hva_ctx_dbg *dbg = &ctx->dbg; 183 ktime_t end = ktime_get(); 184 185 /* stream bytesused and timestamp in us */ 186 bytesused = vb2_get_plane_payload(&stream->vbuf.vb2_buf, 0); 187 div = stream->vbuf.vb2_buf.timestamp; 188 do_div(div, 1000); 189 timestamp = (u32)div; 190 191 /* encoding duration */ 192 div = (u64)ktime_us_delta(end, dbg->begin); 193 194 dev_dbg(dev, 195 "%s perf stream[%d] dts=%d encoded using %d bytes in %d us", 196 ctx->name, 197 stream->vbuf.sequence, 198 timestamp, 199 bytesused, (u32)div); 200 201 do_div(div, 100); 202 duration = (u32)div; 203 204 dbg->min_duration = min(duration, dbg->min_duration); 205 dbg->max_duration = max(duration, dbg->max_duration); 206 dbg->total_duration += duration; 207 dbg->cnt_duration++; 208 209 /* 210 * the average bitrate is based on the total stream size 211 * and the total encoding periods 212 */ 213 dbg->total_stream_size += bytesused; 214 dbg->window_stream_size += bytesused; 215 216 dbg->is_valid_period = true; 217 } 218 219 static void hva_dbg_perf_compute(struct hva_ctx *ctx) 220 { 221 u64 div; 222 struct hva_ctx_dbg *dbg = &ctx->dbg; 223 224 if (dbg->cnt_duration > 0) { 225 div = (u64)dbg->total_duration; 226 do_div(div, dbg->cnt_duration); 227 dbg->avg_duration = (u32)div; 228 } else { 229 dbg->avg_duration = 0; 230 } 231 232 if (dbg->total_duration > 0) { 233 div = (u64)dbg->cnt_duration * 100000; 234 do_div(div, dbg->total_duration); 235 dbg->max_fps = (u32)div; 236 } else { 237 dbg->max_fps = 0; 238 } 239 240 if (dbg->cnt_period > 0) { 241 div = (u64)dbg->total_period; 242 do_div(div, dbg->cnt_period); 243 dbg->avg_period = (u32)div; 244 } else { 245 dbg->avg_period = 0; 246 } 247 248 if (dbg->total_period > 0) { 249 div = (u64)dbg->cnt_period * 100000; 250 do_div(div, dbg->total_period); 251 dbg->avg_fps = (u32)div; 252 } else { 253 dbg->avg_fps = 0; 254 } 255 256 if (dbg->total_period > 0) { 257 /* 258 * bitrate in kbps = (video size * 8 / 1000) / 259 * (video duration / 10000) 260 * = video size * 80 / video duration 261 */ 262 div = (u64)dbg->total_stream_size * 80; 263 do_div(div, dbg->total_period); 264 dbg->avg_bitrate = (u32)div; 265 } else { 266 dbg->avg_bitrate = 0; 267 } 268 } 269 270 /* 271 * device debug info 272 */ 273 274 static int device_show(struct seq_file *s, void *data) 275 { 276 struct hva_dev *hva = s->private; 277 278 seq_printf(s, "[%s]\n", hva->v4l2_dev.name); 279 seq_printf(s, "registered as /dev/video%d\n", hva->vdev->num); 280 281 return 0; 282 } 283 284 static int encoders_show(struct seq_file *s, void *data) 285 { 286 struct hva_dev *hva = s->private; 287 unsigned int i = 0; 288 289 seq_printf(s, "[encoders]\n|- %d registered encoders:\n", 290 hva->nb_of_encoders); 291 292 while (hva->encoders[i]) { 293 seq_printf(s, "|- %s: %4.4s => %4.4s\n", hva->encoders[i]->name, 294 (char *)&hva->encoders[i]->pixelformat, 295 (char *)&hva->encoders[i]->streamformat); 296 i++; 297 } 298 299 return 0; 300 } 301 302 static int last_show(struct seq_file *s, void *data) 303 { 304 struct hva_dev *hva = s->private; 305 struct hva_ctx *last_ctx = &hva->dbg.last_ctx; 306 307 if (last_ctx->flags & HVA_FLAG_STREAMINFO) { 308 seq_puts(s, "[last encoding]\n"); 309 310 hva_dbg_perf_compute(last_ctx); 311 format_ctx(s, last_ctx); 312 } else { 313 seq_puts(s, "[no information recorded about last encoding]\n"); 314 } 315 316 return 0; 317 } 318 319 static int regs_show(struct seq_file *s, void *data) 320 { 321 struct hva_dev *hva = s->private; 322 323 hva_hw_dump_regs(hva, s); 324 325 return 0; 326 } 327 328 #define hva_dbg_create_entry(name) \ 329 debugfs_create_file(#name, 0444, hva->dbg.debugfs_entry, hva, \ 330 &name##_fops) 331 332 DEFINE_SHOW_ATTRIBUTE(device); 333 DEFINE_SHOW_ATTRIBUTE(encoders); 334 DEFINE_SHOW_ATTRIBUTE(last); 335 DEFINE_SHOW_ATTRIBUTE(regs); 336 337 void hva_debugfs_create(struct hva_dev *hva) 338 { 339 hva->dbg.debugfs_entry = debugfs_create_dir(HVA_NAME, NULL); 340 341 hva_dbg_create_entry(device); 342 hva_dbg_create_entry(encoders); 343 hva_dbg_create_entry(last); 344 hva_dbg_create_entry(regs); 345 } 346 347 void hva_debugfs_remove(struct hva_dev *hva) 348 { 349 debugfs_remove_recursive(hva->dbg.debugfs_entry); 350 hva->dbg.debugfs_entry = NULL; 351 } 352 353 /* 354 * context (instance) debug info 355 */ 356 357 static int ctx_show(struct seq_file *s, void *data) 358 { 359 struct hva_ctx *ctx = s->private; 360 361 seq_printf(s, "[running encoding %d]\n", ctx->id); 362 363 hva_dbg_perf_compute(ctx); 364 format_ctx(s, ctx); 365 366 return 0; 367 } 368 369 DEFINE_SHOW_ATTRIBUTE(ctx); 370 371 void hva_dbg_ctx_create(struct hva_ctx *ctx) 372 { 373 struct hva_dev *hva = ctx->hva_dev; 374 char name[4] = ""; 375 376 ctx->dbg.min_duration = UINT_MAX; 377 ctx->dbg.min_period = UINT_MAX; 378 ctx->dbg.min_bitrate = UINT_MAX; 379 380 snprintf(name, sizeof(name), "%d", hva->instance_id); 381 382 ctx->dbg.debugfs_entry = debugfs_create_file(name, 0444, 383 hva->dbg.debugfs_entry, 384 ctx, &ctx_fops); 385 } 386 387 void hva_dbg_ctx_remove(struct hva_ctx *ctx) 388 { 389 struct hva_dev *hva = ctx->hva_dev; 390 391 if (ctx->flags & HVA_FLAG_STREAMINFO) 392 /* save context before removing */ 393 memcpy(&hva->dbg.last_ctx, ctx, sizeof(*ctx)); 394 395 debugfs_remove(ctx->dbg.debugfs_entry); 396 } 397