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