drivers/gpu/drm/imagination/pvr_fw_trace.c

   1 // SPDX-License-Identifier: GPL-2.0-only OR MIT
   2 /* Copyright (c) 2023 Imagination Technologies Ltd. */
   3
   4 #include "pvr_device.h"
   5 #include "pvr_gem.h"
   6 #include "pvr_rogue_fwif.h"
   7 #include "pvr_rogue_fwif_sf.h"
   8 #include "pvr_fw_trace.h"
   9
  10 #include <drm/drm_drv.h>
  11 #include <drm/drm_file.h>
  12
  13 #include <linux/build_bug.h>
  14 #include <linux/dcache.h>
  15 #include <linux/sysfs.h>
  16 #include <linux/types.h>
  17
  18 static void
  19 tracebuf_ctrl_init(void *cpu_ptr, void *priv)
  20 {
  21         struct rogue_fwif_tracebuf *tracebuf_ctrl = cpu_ptr;
  22         struct pvr_fw_trace *fw_trace = priv;
  23         u32 thread_nr;
  24
  25         tracebuf_ctrl->tracebuf_size_in_dwords = ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS;
  26         tracebuf_ctrl->tracebuf_flags = 0;
  27
  28         if (fw_trace->group_mask)
  29                 tracebuf_ctrl->log_type = fw_trace->group_mask | ROGUE_FWIF_LOG_TYPE_TRACE;
  30         else
  31                 tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE;
  32
  33         for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) {
  34                 struct rogue_fwif_tracebuf_space *tracebuf_space =
  35                         &tracebuf_ctrl->tracebuf[thread_nr];
  36                 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr];
  37
  38                 pvr_fw_object_get_fw_addr(trace_buffer->buf_obj,
  39                                           &tracebuf_space->trace_buffer_fw_addr);
  40
  41                 tracebuf_space->trace_buffer = trace_buffer->buf;
  42                 tracebuf_space->trace_pointer = 0;
  43         }
  44 }
  45
  46 int pvr_fw_trace_init(struct pvr_device *pvr_dev)
  47 {
  48         struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace;
  49         struct drm_device *drm_dev = from_pvr_device(pvr_dev);
  50         u32 thread_nr;
  51         int err;
  52
  53         for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) {
  54                 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr];
  55
  56                 trace_buffer->buf =
  57                         pvr_fw_object_create_and_map(pvr_dev,
  58                                                      ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS *
  59                                                      sizeof(*trace_buffer->buf),
  60                                                      PVR_BO_FW_FLAGS_DEVICE_UNCACHED |
  61                                                      PVR_BO_FW_NO_CLEAR_ON_RESET,
  62                                                      NULL, NULL, &trace_buffer->buf_obj);
  63                 if (IS_ERR(trace_buffer->buf)) {
  64                         drm_err(drm_dev, "Unable to allocate trace buffer\n");
  65                         err = PTR_ERR(trace_buffer->buf);
  66                         trace_buffer->buf = NULL;
  67                         goto err_free_buf;
  68                 }
  69         }
  70
  71         /* TODO: Provide control of group mask. */
  72         fw_trace->group_mask = 0;
  73
  74         fw_trace->tracebuf_ctrl =
  75                 pvr_fw_object_create_and_map(pvr_dev,
  76                                              sizeof(*fw_trace->tracebuf_ctrl),
  77                                              PVR_BO_FW_FLAGS_DEVICE_UNCACHED |
  78                                              PVR_BO_FW_NO_CLEAR_ON_RESET,
  79                                              tracebuf_ctrl_init, fw_trace,
  80                                              &fw_trace->tracebuf_ctrl_obj);
  81         if (IS_ERR(fw_trace->tracebuf_ctrl)) {
  82                 drm_err(drm_dev, "Unable to allocate trace buffer control structure\n");
  83                 err = PTR_ERR(fw_trace->tracebuf_ctrl);
  84                 goto err_free_buf;
  85         }
  86
  87         BUILD_BUG_ON(ARRAY_SIZE(fw_trace->tracebuf_ctrl->tracebuf) !=
  88                      ARRAY_SIZE(fw_trace->buffers));
  89
  90         for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) {
  91                 struct rogue_fwif_tracebuf_space *tracebuf_space =
  92                         &fw_trace->tracebuf_ctrl->tracebuf[thread_nr];
  93                 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr];
  94
  95                 trace_buffer->tracebuf_space = tracebuf_space;
  96         }
  97
  98         return 0;
  99
 100 err_free_buf:
 101         for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) {
 102                 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr];
 103
 104                 if (trace_buffer->buf)
 105                         pvr_fw_object_unmap_and_destroy(trace_buffer->buf_obj);
 106         }
 107
 108         return err;
 109 }
 110
 111 void pvr_fw_trace_fini(struct pvr_device *pvr_dev)
 112 {
 113         struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace;
 114         u32 thread_nr;
 115
 116         for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) {
 117                 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr];
 118
 119                 pvr_fw_object_unmap_and_destroy(trace_buffer->buf_obj);
 120         }
 121         pvr_fw_object_unmap_and_destroy(fw_trace->tracebuf_ctrl_obj);
 122 }
 123
 124 #if defined(CONFIG_DEBUG_FS)
 125
 126 /**
 127  * update_logtype() - Send KCCB command to trigger FW to update logtype
 128  * @pvr_dev: Target PowerVR device
 129  * @group_mask: New log group mask.
 130  *
 131  * Returns:
 132  *  * 0 on success,
 133  *  * Any error returned by pvr_kccb_send_cmd(), or
 134  *  * -%EIO if the device is lost.
 135  */
 136 static int
 137 update_logtype(struct pvr_device *pvr_dev, u32 group_mask)
 138 {
 139         struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace;
 140         struct rogue_fwif_kccb_cmd cmd;
 141         int idx;
 142         int err;
 143
 144         if (group_mask)
 145                 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_TRACE | group_mask;
 146         else
 147                 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE;
 148
 149         fw_trace->group_mask = group_mask;
 150
 151         down_read(&pvr_dev->reset_sem);
 152         if (!drm_dev_enter(from_pvr_device(pvr_dev), &idx)) {
 153                 err = -EIO;
 154                 goto err_up_read;
 155         }
 156
 157         cmd.cmd_type = ROGUE_FWIF_KCCB_CMD_LOGTYPE_UPDATE;
 158         cmd.kccb_flags = 0;
 159
 160         err = pvr_kccb_send_cmd(pvr_dev, &cmd, NULL);
 161
 162         drm_dev_exit(idx);
 163
 164 err_up_read:
 165         up_read(&pvr_dev->reset_sem);
 166
 167         return err;
 168 }
 169
 170 struct pvr_fw_trace_seq_data {
 171         /** @buffer: Pointer to copy of trace data. */
 172         u32 *buffer;
 173
 174         /** @start_offset: Starting offset in trace data, as reported by FW. */
 175         u32 start_offset;
 176
 177         /** @idx: Current index into trace data. */
 178         u32 idx;
 179
 180         /** @assert_buf: Trace assert buffer, as reported by FW. */
 181         struct rogue_fwif_file_info_buf assert_buf;
 182 };
 183
 184 static u32 find_sfid(u32 id)
 185 {
 186         u32 i;
 187
 188         for (i = 0; i < ARRAY_SIZE(stid_fmts); i++) {
 189                 if (stid_fmts[i].id == id)
 190                         return i;
 191         }
 192
 193         return ROGUE_FW_SF_LAST;
 194 }
 195
 196 static u32 read_fw_trace(struct pvr_fw_trace_seq_data *trace_seq_data, u32 offset)
 197 {
 198         u32 idx;
 199
 200         idx = trace_seq_data->idx + offset;
 201         if (idx >= ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS)
 202                 return 0;
 203
 204         idx = (idx + trace_seq_data->start_offset) % ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS;
 205         return trace_seq_data->buffer[idx];
 206 }
 207
 208 /**
 209  * fw_trace_get_next() - Advance trace index to next entry
 210  * @trace_seq_data: Trace sequence data.
 211  *
 212  * Returns:
 213  *  * %true if trace index is now pointing to a valid entry, or
 214  *  * %false if trace index is pointing to an invalid entry, or has hit the end
 215  *    of the trace.
 216  */
 217 static bool fw_trace_get_next(struct pvr_fw_trace_seq_data *trace_seq_data)
 218 {
 219         u32 id, sf_id;
 220
 221         while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) {
 222                 id = read_fw_trace(trace_seq_data, 0);
 223                 trace_seq_data->idx++;
 224                 if (!ROGUE_FW_LOG_VALIDID(id))
 225                         continue;
 226                 if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) {
 227                         /* Assertion failure marks the end of the trace. */
 228                         return false;
 229                 }
 230
 231                 sf_id = find_sfid(id);
 232                 if (sf_id == ROGUE_FW_SF_FIRST)
 233                         continue;
 234                 if (sf_id == ROGUE_FW_SF_LAST) {
 235                         /*
 236                          * Could not match with an ID in the SF table, trace is
 237                          * most likely corrupt from this point.
 238                          */
 239                         return false;
 240                 }
 241
 242                 /* Skip over the timestamp, and any parameters. */
 243                 trace_seq_data->idx += 2 + ROGUE_FW_SF_PARAMNUM(id);
 244
 245                 /* Ensure index is now pointing to a valid trace entry. */
 246                 id = read_fw_trace(trace_seq_data, 0);
 247                 if (!ROGUE_FW_LOG_VALIDID(id))
 248                         continue;
 249
 250                 return true;
 251         }
 252
 253         /* Hit end of trace data. */
 254         return false;
 255 }
 256
 257 /**
 258  * fw_trace_get_first() - Find first valid entry in trace
 259  * @trace_seq_data: Trace sequence data.
 260  *
 261  * Skips over invalid (usually zero) and ROGUE_FW_SF_FIRST entries.
 262  *
 263  * If the trace has no valid entries, this function will exit with the trace
 264  * index pointing to the end of the trace. trace_seq_show() will return an error
 265  * in this state.
 266  */
 267 static void fw_trace_get_first(struct pvr_fw_trace_seq_data *trace_seq_data)
 268 {
 269         trace_seq_data->idx = 0;
 270
 271         while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) {
 272                 u32 id = read_fw_trace(trace_seq_data, 0);
 273
 274                 if (ROGUE_FW_LOG_VALIDID(id)) {
 275                         u32 sf_id = find_sfid(id);
 276
 277                         if (sf_id != ROGUE_FW_SF_FIRST)
 278                                 break;
 279                 }
 280                 trace_seq_data->idx++;
 281         }
 282 }
 283
 284 static void *fw_trace_seq_start(struct seq_file *s, loff_t *pos)
 285 {
 286         struct pvr_fw_trace_seq_data *trace_seq_data = s->private;
 287         u32 i;
 288
 289         /* Reset trace index, then advance to *pos. */
 290         fw_trace_get_first(trace_seq_data);
 291
 292         for (i = 0; i < *pos; i++) {
 293                 if (!fw_trace_get_next(trace_seq_data))
 294                         return NULL;
 295         }
 296
 297         return (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) ? pos : NULL;
 298 }
 299
 300 static void *fw_trace_seq_next(struct seq_file *s, void *v, loff_t *pos)
 301 {
 302         struct pvr_fw_trace_seq_data *trace_seq_data = s->private;
 303
 304         (*pos)++;
 305         if (!fw_trace_get_next(trace_seq_data))
 306                 return NULL;
 307
 308         return (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) ? pos : NULL;
 309 }
 310
 311 static void fw_trace_seq_stop(struct seq_file *s, void *v)
 312 {
 313 }
 314
 315 static int fw_trace_seq_show(struct seq_file *s, void *v)
 316 {
 317         struct pvr_fw_trace_seq_data *trace_seq_data = s->private;
 318         u64 timestamp;
 319         u32 id;
 320         u32 sf_id;
 321
 322         if (trace_seq_data->idx >= ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS)
 323                 return -EINVAL;
 324
 325         id = read_fw_trace(trace_seq_data, 0);
 326         /* Index is not pointing at a valid entry. */
 327         if (!ROGUE_FW_LOG_VALIDID(id))
 328                 return -EINVAL;
 329
 330         sf_id = find_sfid(id);
 331         /* Index is not pointing at a valid entry. */
 332         if (sf_id == ROGUE_FW_SF_LAST)
 333                 return -EINVAL;
 334
 335         timestamp = read_fw_trace(trace_seq_data, 1) |
 336                 ((u64)read_fw_trace(trace_seq_data, 2) << 32);
 337         timestamp = (timestamp & ~ROGUE_FWT_TIMESTAMP_TIME_CLRMSK) >>
 338                 ROGUE_FWT_TIMESTAMP_TIME_SHIFT;
 339
 340         seq_printf(s, "[%llu] : ", timestamp);
 341         if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) {
 342                 seq_printf(s, "ASSERTION %s failed at %s:%u",
 343                            trace_seq_data->assert_buf.info,
 344                            trace_seq_data->assert_buf.path,
 345                            trace_seq_data->assert_buf.line_num);
 346         } else {
 347                 seq_printf(s, stid_fmts[sf_id].name,
 348                            read_fw_trace(trace_seq_data, 3),
 349                            read_fw_trace(trace_seq_data, 4),
 350                            read_fw_trace(trace_seq_data, 5),
 351                            read_fw_trace(trace_seq_data, 6),
 352                            read_fw_trace(trace_seq_data, 7),
 353                            read_fw_trace(trace_seq_data, 8),
 354                            read_fw_trace(trace_seq_data, 9),
 355                            read_fw_trace(trace_seq_data, 10),
 356                            read_fw_trace(trace_seq_data, 11),
 357                            read_fw_trace(trace_seq_data, 12),
 358                            read_fw_trace(trace_seq_data, 13),
 359                            read_fw_trace(trace_seq_data, 14),
 360                            read_fw_trace(trace_seq_data, 15),
 361                            read_fw_trace(trace_seq_data, 16),
 362                            read_fw_trace(trace_seq_data, 17),
 363                            read_fw_trace(trace_seq_data, 18),
 364                            read_fw_trace(trace_seq_data, 19),
 365                            read_fw_trace(trace_seq_data, 20),
 366                            read_fw_trace(trace_seq_data, 21),
 367                            read_fw_trace(trace_seq_data, 22));
 368         }
 369         seq_puts(s, "\n");
 370         return 0;
 371 }
 372
 373 static const struct seq_operations pvr_fw_trace_seq_ops = {
 374         .start = fw_trace_seq_start,
 375         .next = fw_trace_seq_next,
 376         .stop = fw_trace_seq_stop,
 377         .show = fw_trace_seq_show
 378 };
 379
 380 static int fw_trace_open(struct inode *inode, struct file *file)
 381 {
 382         struct pvr_fw_trace_buffer *trace_buffer = inode->i_private;
 383         struct rogue_fwif_tracebuf_space *tracebuf_space =
 384                 trace_buffer->tracebuf_space;
 385         struct pvr_fw_trace_seq_data *trace_seq_data;
 386         int err;
 387
 388         trace_seq_data = kzalloc(sizeof(*trace_seq_data), GFP_KERNEL);
 389         if (!trace_seq_data)
 390                 return -ENOMEM;
 391
 392         trace_seq_data->buffer = kcalloc(ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS,
 393                                          sizeof(*trace_seq_data->buffer), GFP_KERNEL);
 394         if (!trace_seq_data->buffer) {
 395                 err = -ENOMEM;
 396                 goto err_free_data;
 397         }
 398
 399         /*
 400          * Take a local copy of the trace buffer, as firmware may still be
 401          * writing to it. This will exist as long as this file is open.
 402          */
 403         memcpy(trace_seq_data->buffer, trace_buffer->buf,
 404                ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS * sizeof(u32));
 405         trace_seq_data->start_offset = READ_ONCE(tracebuf_space->trace_pointer);
 406         trace_seq_data->assert_buf = tracebuf_space->assert_buf;
 407         fw_trace_get_first(trace_seq_data);
 408
 409         err = seq_open(file, &pvr_fw_trace_seq_ops);
 410         if (err)
 411                 goto err_free_buffer;
 412
 413         ((struct seq_file *)file->private_data)->private = trace_seq_data;
 414
 415         return 0;
 416
 417 err_free_buffer:
 418         kfree(trace_seq_data->buffer);
 419
 420 err_free_data:
 421         kfree(trace_seq_data);
 422
 423         return err;
 424 }
 425
 426 static int fw_trace_release(struct inode *inode, struct file *file)
 427 {
 428         struct pvr_fw_trace_seq_data *trace_seq_data =
 429                 ((struct seq_file *)file->private_data)->private;
 430
 431         seq_release(inode, file);
 432         kfree(trace_seq_data->buffer);
 433         kfree(trace_seq_data);
 434
 435         return 0;
 436 }
 437
 438 static const struct file_operations pvr_fw_trace_fops = {
 439         .owner = THIS_MODULE,
 440         .open = fw_trace_open,
 441         .read = seq_read,
 442         .llseek = seq_lseek,
 443         .release = fw_trace_release,
 444 };
 445
 446 void
 447 pvr_fw_trace_mask_update(struct pvr_device *pvr_dev, u32 old_mask, u32 new_mask)
 448 {
 449         if (old_mask != new_mask)
 450                 update_logtype(pvr_dev, new_mask);
 451 }
 452
 453 void
 454 pvr_fw_trace_debugfs_init(struct pvr_device *pvr_dev, struct dentry *dir)
 455 {
 456         struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace;
 457         u32 thread_nr;
 458
 459         static_assert(ARRAY_SIZE(fw_trace->buffers) <= 10,
 460                       "The filename buffer is only large enough for a single-digit thread count");
 461
 462         for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); ++thread_nr) {
 463                 char filename[8];
 464
 465                 snprintf(filename, ARRAY_SIZE(filename), "trace_%u", thread_nr);
 466                 debugfs_create_file(filename, 0400, dir,
 467                                     &fw_trace->buffers[thread_nr],
 468                                     &pvr_fw_trace_fops);
 469         }
 470 }
 471 #endif