drivers/media/platform/amphion/vpu_dbg.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2020-2021 NXP
   4  */
   5
   6 #include <linux/init.h>
   7 #include <linux/device.h>
   8 #include <linux/ioctl.h>
   9 #include <linux/list.h>
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/types.h>
  13 #include <linux/pm_runtime.h>
  14 #include <media/v4l2-device.h>
  15 #include <linux/debugfs.h>
  16 #include "vpu.h"
  17 #include "vpu_defs.h"
  18 #include "vpu_core.h"
  19 #include "vpu_helpers.h"
  20 #include "vpu_cmds.h"
  21 #include "vpu_rpc.h"
  22 #include "vpu_v4l2.h"
  23
  24 struct print_buf_desc {
  25         u32 start_h_phy;
  26         u32 start_h_vir;
  27         u32 start_m;
  28         u32 bytes;
  29         u32 read;
  30         u32 write;
  31         char buffer[];
  32 };
  33
  34 static char *vb2_stat_name[] = {
  35         [VB2_BUF_STATE_DEQUEUED] = "dequeued",
  36         [VB2_BUF_STATE_IN_REQUEST] = "in_request",
  37         [VB2_BUF_STATE_PREPARING] = "preparing",
  38         [VB2_BUF_STATE_QUEUED] = "queued",
  39         [VB2_BUF_STATE_ACTIVE] = "active",
  40         [VB2_BUF_STATE_DONE] = "done",
  41         [VB2_BUF_STATE_ERROR] = "error",
  42 };
  43
  44 static char *vpu_stat_name[] = {
  45         [VPU_BUF_STATE_IDLE] = "idle",
  46         [VPU_BUF_STATE_INUSE] = "inuse",
  47         [VPU_BUF_STATE_DECODED] = "decoded",
  48         [VPU_BUF_STATE_READY] = "ready",
  49         [VPU_BUF_STATE_SKIP] = "skip",
  50         [VPU_BUF_STATE_ERROR] = "error",
  51 };
  52
  53 static int vpu_dbg_instance(struct seq_file *s, void *data)
  54 {
  55         struct vpu_inst *inst = s->private;
  56         char str[128];
  57         int num;
  58         struct vb2_queue *vq;
  59         int i;
  60
  61         if (!inst->fh.m2m_ctx)
  62                 return 0;
  63         num = scnprintf(str, sizeof(str), "[%s]\n", vpu_core_type_desc(inst->type));
  64         if (seq_write(s, str, num))
  65                 return 0;
  66
  67         num = scnprintf(str, sizeof(str), "tgig = %d,pid = %d\n", inst->tgid, inst->pid);
  68         if (seq_write(s, str, num))
  69                 return 0;
  70         num = scnprintf(str, sizeof(str), "state = %d\n", inst->state);
  71         if (seq_write(s, str, num))
  72                 return 0;
  73         num = scnprintf(str, sizeof(str),
  74                         "min_buffer_out = %d, min_buffer_cap = %d\n",
  75                         inst->min_buffer_out, inst->min_buffer_cap);
  76         if (seq_write(s, str, num))
  77                 return 0;
  78
  79         vq = v4l2_m2m_get_src_vq(inst->fh.m2m_ctx);
  80         num = scnprintf(str, sizeof(str),
  81                         "output (%2d, %2d): fmt = %c%c%c%c %d x %d, %d;",
  82                         vb2_is_streaming(vq),
  83                         vq->num_buffers,
  84                         inst->out_format.pixfmt,
  85                         inst->out_format.pixfmt >> 8,
  86                         inst->out_format.pixfmt >> 16,
  87                         inst->out_format.pixfmt >> 24,
  88                         inst->out_format.width,
  89                         inst->out_format.height,
  90                         vq->last_buffer_dequeued);
  91         if (seq_write(s, str, num))
  92                 return 0;
  93         for (i = 0; i < inst->out_format.mem_planes; i++) {
  94                 num = scnprintf(str, sizeof(str), " %d(%d)",
  95                                 vpu_get_fmt_plane_size(&inst->out_format, i),
  96                                 inst->out_format.bytesperline[i]);
  97                 if (seq_write(s, str, num))
  98                         return 0;
  99         }
 100         if (seq_write(s, "\n", 1))
 101                 return 0;
 102
 103         vq = v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx);
 104         num = scnprintf(str, sizeof(str),
 105                         "capture(%2d, %2d): fmt = %c%c%c%c %d x %d, %d;",
 106                         vb2_is_streaming(vq),
 107                         vq->num_buffers,
 108                         inst->cap_format.pixfmt,
 109                         inst->cap_format.pixfmt >> 8,
 110                         inst->cap_format.pixfmt >> 16,
 111                         inst->cap_format.pixfmt >> 24,
 112                         inst->cap_format.width,
 113                         inst->cap_format.height,
 114                         vq->last_buffer_dequeued);
 115         if (seq_write(s, str, num))
 116                 return 0;
 117         for (i = 0; i < inst->cap_format.mem_planes; i++) {
 118                 num = scnprintf(str, sizeof(str), " %d(%d)",
 119                                 vpu_get_fmt_plane_size(&inst->cap_format, i),
 120                                 inst->cap_format.bytesperline[i]);
 121                 if (seq_write(s, str, num))
 122                         return 0;
 123         }
 124         if (seq_write(s, "\n", 1))
 125                 return 0;
 126         num = scnprintf(str, sizeof(str), "crop: (%d, %d) %d x %d\n",
 127                         inst->crop.left,
 128                         inst->crop.top,
 129                         inst->crop.width,
 130                         inst->crop.height);
 131         if (seq_write(s, str, num))
 132                 return 0;
 133
 134         vq = v4l2_m2m_get_src_vq(inst->fh.m2m_ctx);
 135         for (i = 0; i < vq->num_buffers; i++) {
 136                 struct vb2_buffer *vb = vq->bufs[i];
 137                 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 138
 139                 if (vb->state == VB2_BUF_STATE_DEQUEUED)
 140                         continue;
 141                 num = scnprintf(str, sizeof(str),
 142                                 "output [%2d] state = %10s, %8s\n",
 143                                 i, vb2_stat_name[vb->state],
 144                                 vpu_stat_name[vpu_get_buffer_state(vbuf)]);
 145                 if (seq_write(s, str, num))
 146                         return 0;
 147         }
 148
 149         vq = v4l2_m2m_get_dst_vq(inst->fh.m2m_ctx);
 150         for (i = 0; i < vq->num_buffers; i++) {
 151                 struct vb2_buffer *vb = vq->bufs[i];
 152                 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 153
 154                 if (vb->state == VB2_BUF_STATE_DEQUEUED)
 155                         continue;
 156                 num = scnprintf(str, sizeof(str),
 157                                 "capture[%2d] state = %10s, %8s\n",
 158                                 i, vb2_stat_name[vb->state],
 159                                 vpu_stat_name[vpu_get_buffer_state(vbuf)]);
 160                 if (seq_write(s, str, num))
 161                         return 0;
 162         }
 163
 164         num = scnprintf(str, sizeof(str), "sequence = %d\n", inst->sequence);
 165         if (seq_write(s, str, num))
 166                 return 0;
 167
 168         if (inst->use_stream_buffer) {
 169                 num = scnprintf(str, sizeof(str), "stream_buffer = %d / %d, <%pad, 0x%x>\n",
 170                                 vpu_helper_get_used_space(inst),
 171                                 inst->stream_buffer.length,
 172                                 &inst->stream_buffer.phys,
 173                                 inst->stream_buffer.length);
 174                 if (seq_write(s, str, num))
 175                         return 0;
 176         }
 177         num = scnprintf(str, sizeof(str), "kfifo len = 0x%x\n", kfifo_len(&inst->msg_fifo));
 178         if (seq_write(s, str, num))
 179                 return 0;
 180
 181         num = scnprintf(str, sizeof(str), "flow :\n");
 182         if (seq_write(s, str, num))
 183                 return 0;
 184
 185         mutex_lock(&inst->core->cmd_lock);
 186         for (i = 0; i < ARRAY_SIZE(inst->flows); i++) {
 187                 u32 idx = (inst->flow_idx + i) % (ARRAY_SIZE(inst->flows));
 188
 189                 if (!inst->flows[idx])
 190                         continue;
 191                 num = scnprintf(str, sizeof(str), "\t[%s]0x%x\n",
 192                                 inst->flows[idx] >= VPU_MSG_ID_NOOP ? "M" : "C",
 193                                 inst->flows[idx]);
 194                 if (seq_write(s, str, num)) {
 195                         mutex_unlock(&inst->core->cmd_lock);
 196                         return 0;
 197                 }
 198         }
 199         mutex_unlock(&inst->core->cmd_lock);
 200
 201         i = 0;
 202         while (true) {
 203                 num = call_vop(inst, get_debug_info, str, sizeof(str), i++);
 204                 if (num <= 0)
 205                         break;
 206                 if (seq_write(s, str, num))
 207                         return 0;
 208         }
 209
 210         return 0;
 211 }
 212
 213 static int vpu_dbg_core(struct seq_file *s, void *data)
 214 {
 215         struct vpu_core *core = s->private;
 216         struct vpu_shared_addr *iface = core->iface;
 217         char str[128];
 218         int num;
 219
 220         num = scnprintf(str, sizeof(str), "[%s]\n", vpu_core_type_desc(core->type));
 221         if (seq_write(s, str, num))
 222                 return 0;
 223
 224         num = scnprintf(str, sizeof(str), "boot_region  = <%pad, 0x%x>\n",
 225                         &core->fw.phys, core->fw.length);
 226         if (seq_write(s, str, num))
 227                 return 0;
 228         num = scnprintf(str, sizeof(str), "rpc_region   = <%pad, 0x%x> used = 0x%x\n",
 229                         &core->rpc.phys, core->rpc.length, core->rpc.bytesused);
 230         if (seq_write(s, str, num))
 231                 return 0;
 232         num = scnprintf(str, sizeof(str), "fwlog_region = <%pad, 0x%x>\n",
 233                         &core->log.phys, core->log.length);
 234         if (seq_write(s, str, num))
 235                 return 0;
 236
 237         num = scnprintf(str, sizeof(str), "power %s\n",
 238                         vpu_iface_get_power_state(core) ? "on" : "off");
 239         if (seq_write(s, str, num))
 240                 return 0;
 241         num = scnprintf(str, sizeof(str), "state = %d\n", core->state);
 242         if (seq_write(s, str, num))
 243                 return 0;
 244         if (core->state == VPU_CORE_DEINIT)
 245                 return 0;
 246         num = scnprintf(str, sizeof(str), "fw version = %d.%d.%d\n",
 247                         (core->fw_version >> 16) & 0xff,
 248                         (core->fw_version >> 8) & 0xff,
 249                         core->fw_version & 0xff);
 250         if (seq_write(s, str, num))
 251                 return 0;
 252         num = scnprintf(str, sizeof(str), "instances = %d/%d (0x%02lx), %d\n",
 253                         hweight32(core->instance_mask),
 254                         core->supported_instance_count,
 255                         core->instance_mask,
 256                         core->request_count);
 257         if (seq_write(s, str, num))
 258                 return 0;
 259         num = scnprintf(str, sizeof(str), "kfifo len = 0x%x\n", kfifo_len(&core->msg_fifo));
 260         if (seq_write(s, str, num))
 261                 return 0;
 262         num = scnprintf(str, sizeof(str),
 263                         "cmd_buf:[0x%x, 0x%x], wptr = 0x%x, rptr = 0x%x\n",
 264                         iface->cmd_desc->start,
 265                         iface->cmd_desc->end,
 266                         iface->cmd_desc->wptr,
 267                         iface->cmd_desc->rptr);
 268         if (seq_write(s, str, num))
 269                 return 0;
 270         num = scnprintf(str, sizeof(str),
 271                         "msg_buf:[0x%x, 0x%x], wptr = 0x%x, rptr = 0x%x\n",
 272                         iface->msg_desc->start,
 273                         iface->msg_desc->end,
 274                         iface->msg_desc->wptr,
 275                         iface->msg_desc->rptr);
 276         if (seq_write(s, str, num))
 277                 return 0;
 278
 279         return 0;
 280 }
 281
 282 static int vpu_dbg_fwlog(struct seq_file *s, void *data)
 283 {
 284         struct vpu_core *core = s->private;
 285         struct print_buf_desc *print_buf;
 286         int length;
 287         u32 rptr;
 288         u32 wptr;
 289         int ret = 0;
 290
 291         if (!core->log.virt || core->state == VPU_CORE_DEINIT)
 292                 return 0;
 293
 294         print_buf = core->log.virt;
 295         rptr = print_buf->read;
 296         wptr = print_buf->write;
 297
 298         if (rptr == wptr)
 299                 return 0;
 300         else if (rptr < wptr)
 301                 length = wptr - rptr;
 302         else
 303                 length = print_buf->bytes + wptr - rptr;
 304
 305         if (s->count + length >= s->size) {
 306                 s->count = s->size;
 307                 return 0;
 308         }
 309
 310         if (rptr + length >= print_buf->bytes) {
 311                 int num = print_buf->bytes - rptr;
 312
 313                 if (seq_write(s, print_buf->buffer + rptr, num))
 314                         ret = -1;
 315                 length -= num;
 316                 rptr = 0;
 317         }
 318
 319         if (length) {
 320                 if (seq_write(s, print_buf->buffer + rptr, length))
 321                         ret = -1;
 322                 rptr += length;
 323         }
 324         if (!ret)
 325                 print_buf->read = rptr;
 326
 327         return 0;
 328 }
 329
 330 static int vpu_dbg_inst_open(struct inode *inode, struct file *filp)
 331 {
 332         return single_open(filp, vpu_dbg_instance, inode->i_private);
 333 }
 334
 335 static ssize_t vpu_dbg_inst_write(struct file *file,
 336                                   const char __user *user_buf, size_t size, loff_t *ppos)
 337 {
 338         struct seq_file *s = file->private_data;
 339         struct vpu_inst *inst = s->private;
 340
 341         vpu_session_debug(inst);
 342
 343         return size;
 344 }
 345
 346 static ssize_t vpu_dbg_core_write(struct file *file,
 347                                   const char __user *user_buf, size_t size, loff_t *ppos)
 348 {
 349         struct seq_file *s = file->private_data;
 350         struct vpu_core *core = s->private;
 351
 352         pm_runtime_resume_and_get(core->dev);
 353         mutex_lock(&core->lock);
 354         if (vpu_iface_get_power_state(core) && !core->request_count) {
 355                 dev_info(core->dev, "reset\n");
 356                 if (!vpu_core_sw_reset(core)) {
 357                         vpu_core_set_state(core, VPU_CORE_ACTIVE);
 358                         core->hang_mask = 0;
 359                 }
 360         }
 361         mutex_unlock(&core->lock);
 362         pm_runtime_put_sync(core->dev);
 363
 364         return size;
 365 }
 366
 367 static int vpu_dbg_core_open(struct inode *inode, struct file *filp)
 368 {
 369         return single_open(filp, vpu_dbg_core, inode->i_private);
 370 }
 371
 372 static int vpu_dbg_fwlog_open(struct inode *inode, struct file *filp)
 373 {
 374         return single_open(filp, vpu_dbg_fwlog, inode->i_private);
 375 }
 376
 377 static const struct file_operations vpu_dbg_inst_fops = {
 378         .owner = THIS_MODULE,
 379         .open = vpu_dbg_inst_open,
 380         .release = single_release,
 381         .read = seq_read,
 382         .write = vpu_dbg_inst_write,
 383 };
 384
 385 static const struct file_operations vpu_dbg_core_fops = {
 386         .owner = THIS_MODULE,
 387         .open = vpu_dbg_core_open,
 388         .release = single_release,
 389         .read = seq_read,
 390         .write = vpu_dbg_core_write,
 391 };
 392
 393 static const struct file_operations vpu_dbg_fwlog_fops = {
 394         .owner = THIS_MODULE,
 395         .open = vpu_dbg_fwlog_open,
 396         .release = single_release,
 397         .read = seq_read,
 398 };
 399
 400 int vpu_inst_create_dbgfs_file(struct vpu_inst *inst)
 401 {
 402         struct vpu_dev *vpu;
 403         char name[64];
 404
 405         if (!inst || !inst->core || !inst->core->vpu)
 406                 return -EINVAL;
 407
 408         vpu = inst->core->vpu;
 409         if (!vpu->debugfs)
 410                 return -EINVAL;
 411
 412         if (inst->debugfs)
 413                 return 0;
 414
 415         scnprintf(name, sizeof(name), "instance.%d.%d", inst->core->id, inst->id);
 416         inst->debugfs = debugfs_create_file((const char *)name,
 417                                             VERIFY_OCTAL_PERMISSIONS(0644),
 418                                             vpu->debugfs,
 419                                             inst,
 420                                             &vpu_dbg_inst_fops);
 421
 422         return 0;
 423 }
 424
 425 int vpu_inst_remove_dbgfs_file(struct vpu_inst *inst)
 426 {
 427         if (!inst)
 428                 return 0;
 429
 430         debugfs_remove(inst->debugfs);
 431         inst->debugfs = NULL;
 432
 433         return 0;
 434 }
 435
 436 int vpu_core_create_dbgfs_file(struct vpu_core *core)
 437 {
 438         struct vpu_dev *vpu;
 439         char name[64];
 440
 441         if (!core || !core->vpu)
 442                 return -EINVAL;
 443
 444         vpu = core->vpu;
 445         if (!vpu->debugfs)
 446                 return -EINVAL;
 447
 448         if (!core->debugfs) {
 449                 scnprintf(name, sizeof(name), "core.%d", core->id);
 450                 core->debugfs = debugfs_create_file((const char *)name,
 451                                                     VERIFY_OCTAL_PERMISSIONS(0644),
 452                                                     vpu->debugfs,
 453                                                     core,
 454                                                     &vpu_dbg_core_fops);
 455         }
 456         if (!core->debugfs_fwlog) {
 457                 scnprintf(name, sizeof(name), "fwlog.%d", core->id);
 458                 core->debugfs_fwlog = debugfs_create_file((const char *)name,
 459                                                           VERIFY_OCTAL_PERMISSIONS(0444),
 460                                                           vpu->debugfs,
 461                                                           core,
 462                                                           &vpu_dbg_fwlog_fops);
 463         }
 464
 465         return 0;
 466 }
 467
 468 int vpu_core_remove_dbgfs_file(struct vpu_core *core)
 469 {
 470         if (!core)
 471                 return 0;
 472         debugfs_remove(core->debugfs);
 473         core->debugfs = NULL;
 474         debugfs_remove(core->debugfs_fwlog);
 475         core->debugfs_fwlog = NULL;
 476
 477         return 0;
 478 }
 479
 480 void vpu_inst_record_flow(struct vpu_inst *inst, u32 flow)
 481 {
 482         if (!inst)
 483                 return;
 484
 485         inst->flows[inst->flow_idx] = flow;
 486         inst->flow_idx = (inst->flow_idx + 1) % (ARRAY_SIZE(inst->flows));
 487 }