drivers/accel/ivpu/ivpu_fw_log.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2020-2023 Intel Corporation
   4  */
   5
   6 #include <linux/ctype.h>
   7 #include <linux/highmem.h>
   8 #include <linux/fs.h>
   9 #include <linux/slab.h>
  10 #include <linux/moduleparam.h>
  11
  12 #include "vpu_boot_api.h"
  13 #include "ivpu_drv.h"
  14 #include "ivpu_fw.h"
  15 #include "ivpu_fw_log.h"
  16 #include "ivpu_gem.h"
  17
  18 #define IVPU_FW_LOG_LINE_LENGTH   256
  19
  20 unsigned int ivpu_log_level = IVPU_FW_LOG_ERROR;
  21 module_param(ivpu_log_level, uint, 0444);
  22 MODULE_PARM_DESC(ivpu_log_level,
  23                  "VPU firmware default trace level: debug=" __stringify(IVPU_FW_LOG_DEBUG)
  24                  " info=" __stringify(IVPU_FW_LOG_INFO)
  25                  " warn=" __stringify(IVPU_FW_LOG_WARN)
  26                  " error=" __stringify(IVPU_FW_LOG_ERROR)
  27                  " fatal=" __stringify(IVPU_FW_LOG_FATAL));
  28
  29 static int fw_log_ptr(struct ivpu_device *vdev, struct ivpu_bo *bo, u32 *offset,
  30                       struct vpu_tracing_buffer_header **log_header)
  31 {
  32         struct vpu_tracing_buffer_header *log;
  33
  34         if ((*offset + sizeof(*log)) > bo->base.size)
  35                 return -EINVAL;
  36
  37         log = bo->kvaddr + *offset;
  38
  39         if (log->vpu_canary_start != VPU_TRACING_BUFFER_CANARY)
  40                 return -EINVAL;
  41
  42         if (log->header_size < sizeof(*log) || log->header_size > 1024) {
  43                 ivpu_dbg(vdev, FW_BOOT, "Invalid header size 0x%x\n", log->header_size);
  44                 return -EINVAL;
  45         }
  46         if ((char *)log + log->size > (char *)bo->kvaddr + bo->base.size) {
  47                 ivpu_dbg(vdev, FW_BOOT, "Invalid log size 0x%x\n", log->size);
  48                 return -EINVAL;
  49         }
  50
  51         *log_header = log;
  52         *offset += log->size;
  53
  54         ivpu_dbg(vdev, FW_BOOT,
  55                  "FW log name \"%s\", write offset 0x%x size 0x%x, wrap count %d, hdr version %d size %d format %d, alignment %d",
  56                  log->name, log->write_index, log->size, log->wrap_count, log->header_version,
  57                  log->header_size, log->format, log->alignment);
  58
  59         return 0;
  60 }
  61
  62 static void buffer_print(char *buffer, u32 size, struct drm_printer *p)
  63 {
  64         char line[IVPU_FW_LOG_LINE_LENGTH];
  65         u32 index = 0;
  66
  67         if (!size || !buffer)
  68                 return;
  69
  70         while (size--) {
  71                 if (*buffer == '\n' || *buffer == 0) {
  72                         line[index] = 0;
  73                         if (index != 0)
  74                                 drm_printf(p, "%s\n", line);
  75                         index = 0;
  76                         buffer++;
  77                         continue;
  78                 }
  79                 if (index == IVPU_FW_LOG_LINE_LENGTH - 1) {
  80                         line[index] = 0;
  81                         index = 0;
  82                         drm_printf(p, "%s\n", line);
  83                 }
  84                 if (*buffer != '\r' && (isprint(*buffer) || iscntrl(*buffer)))
  85                         line[index++] = *buffer;
  86                 buffer++;
  87         }
  88         line[index] = 0;
  89         if (index != 0)
  90                 drm_printf(p, "%s\n", line);
  91 }
  92
  93 static void fw_log_print_buffer(struct ivpu_device *vdev, struct vpu_tracing_buffer_header *log,
  94                                 const char *prefix, bool only_new_msgs, struct drm_printer *p)
  95 {
  96         char *log_buffer = (void *)log + log->header_size;
  97         u32 log_size = log->size - log->header_size;
  98         u32 log_start = log->read_index;
  99         u32 log_end = log->write_index;
 100
 101         if (!(log->write_index || log->wrap_count) ||
 102             (log->write_index == log->read_index && only_new_msgs)) {
 103                 drm_printf(p, "==== %s \"%s\" log empty ====\n", prefix, log->name);
 104                 return;
 105         }
 106
 107         drm_printf(p, "==== %s \"%s\" log start ====\n", prefix, log->name);
 108         if (log->write_index > log->read_index) {
 109                 buffer_print(log_buffer + log_start, log_end - log_start, p);
 110         } else {
 111                 buffer_print(log_buffer + log_end, log_size - log_end, p);
 112                 buffer_print(log_buffer, log_end, p);
 113         }
 114         drm_printf(p, "\x1b[0m");
 115         drm_printf(p, "==== %s \"%s\" log end   ====\n", prefix, log->name);
 116 }
 117
 118 void ivpu_fw_log_print(struct ivpu_device *vdev, bool only_new_msgs, struct drm_printer *p)
 119 {
 120         struct vpu_tracing_buffer_header *log_header;
 121         u32 next = 0;
 122
 123         while (fw_log_ptr(vdev, vdev->fw->mem_log_crit, &next, &log_header) == 0)
 124                 fw_log_print_buffer(vdev, log_header, "VPU critical", only_new_msgs, p);
 125
 126         next = 0;
 127         while (fw_log_ptr(vdev, vdev->fw->mem_log_verb, &next, &log_header) == 0)
 128                 fw_log_print_buffer(vdev, log_header, "VPU verbose", only_new_msgs, p);
 129 }
 130
 131 void ivpu_fw_log_clear(struct ivpu_device *vdev)
 132 {
 133         struct vpu_tracing_buffer_header *log_header;
 134         u32 next = 0;
 135
 136         while (fw_log_ptr(vdev, vdev->fw->mem_log_crit, &next, &log_header) == 0)
 137                 log_header->read_index = log_header->write_index;
 138
 139         next = 0;
 140         while (fw_log_ptr(vdev, vdev->fw->mem_log_verb, &next, &log_header) == 0)
 141                 log_header->read_index = log_header->write_index;
 142 }