Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Sarah Walker | 1949 | 99.08% | 7 | 77.78% |
Donald Robson | 15 | 0.76% | 1 | 11.11% |
Eric Anholt | 3 | 0.15% | 1 | 11.11% |
Total | 1967 | 9 |
// SPDX-License-Identifier: GPL-2.0-only OR MIT /* Copyright (c) 2023 Imagination Technologies Ltd. */ #include "pvr_device.h" #include "pvr_gem.h" #include "pvr_rogue_fwif.h" #include "pvr_rogue_fwif_sf.h" #include "pvr_fw_trace.h" #include <drm/drm_drv.h> #include <drm/drm_file.h> #include <linux/build_bug.h> #include <linux/dcache.h> #include <linux/debugfs.h> #include <linux/sysfs.h> #include <linux/types.h> static void tracebuf_ctrl_init(void *cpu_ptr, void *priv) { struct rogue_fwif_tracebuf *tracebuf_ctrl = cpu_ptr; struct pvr_fw_trace *fw_trace = priv; u32 thread_nr; tracebuf_ctrl->tracebuf_size_in_dwords = ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS; tracebuf_ctrl->tracebuf_flags = 0; if (fw_trace->group_mask) tracebuf_ctrl->log_type = fw_trace->group_mask | ROGUE_FWIF_LOG_TYPE_TRACE; else tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE; for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { struct rogue_fwif_tracebuf_space *tracebuf_space = &tracebuf_ctrl->tracebuf[thread_nr]; struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; pvr_fw_object_get_fw_addr(trace_buffer->buf_obj, &tracebuf_space->trace_buffer_fw_addr); tracebuf_space->trace_buffer = trace_buffer->buf; tracebuf_space->trace_pointer = 0; } } int pvr_fw_trace_init(struct pvr_device *pvr_dev) { struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; struct drm_device *drm_dev = from_pvr_device(pvr_dev); u32 thread_nr; int err; for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; trace_buffer->buf = pvr_fw_object_create_and_map(pvr_dev, ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS * sizeof(*trace_buffer->buf), PVR_BO_FW_FLAGS_DEVICE_UNCACHED | PVR_BO_FW_NO_CLEAR_ON_RESET, NULL, NULL, &trace_buffer->buf_obj); if (IS_ERR(trace_buffer->buf)) { drm_err(drm_dev, "Unable to allocate trace buffer\n"); err = PTR_ERR(trace_buffer->buf); trace_buffer->buf = NULL; goto err_free_buf; } } /* TODO: Provide control of group mask. */ fw_trace->group_mask = 0; fw_trace->tracebuf_ctrl = pvr_fw_object_create_and_map(pvr_dev, sizeof(*fw_trace->tracebuf_ctrl), PVR_BO_FW_FLAGS_DEVICE_UNCACHED | PVR_BO_FW_NO_CLEAR_ON_RESET, tracebuf_ctrl_init, fw_trace, &fw_trace->tracebuf_ctrl_obj); if (IS_ERR(fw_trace->tracebuf_ctrl)) { drm_err(drm_dev, "Unable to allocate trace buffer control structure\n"); err = PTR_ERR(fw_trace->tracebuf_ctrl); goto err_free_buf; } BUILD_BUG_ON(ARRAY_SIZE(fw_trace->tracebuf_ctrl->tracebuf) != ARRAY_SIZE(fw_trace->buffers)); for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { struct rogue_fwif_tracebuf_space *tracebuf_space = &fw_trace->tracebuf_ctrl->tracebuf[thread_nr]; struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; trace_buffer->tracebuf_space = tracebuf_space; } return 0; err_free_buf: for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; if (trace_buffer->buf) pvr_fw_object_unmap_and_destroy(trace_buffer->buf_obj); } return err; } void pvr_fw_trace_fini(struct pvr_device *pvr_dev) { struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; u32 thread_nr; for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) { struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr]; pvr_fw_object_unmap_and_destroy(trace_buffer->buf_obj); } pvr_fw_object_unmap_and_destroy(fw_trace->tracebuf_ctrl_obj); } #if defined(CONFIG_DEBUG_FS) /** * update_logtype() - Send KCCB command to trigger FW to update logtype * @pvr_dev: Target PowerVR device * @group_mask: New log group mask. * * Returns: * * 0 on success, * * Any error returned by pvr_kccb_send_cmd(), or * * -%EIO if the device is lost. */ static int update_logtype(struct pvr_device *pvr_dev, u32 group_mask) { struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; struct rogue_fwif_kccb_cmd cmd; int idx; int err; if (group_mask) fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_TRACE | group_mask; else fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE; fw_trace->group_mask = group_mask; down_read(&pvr_dev->reset_sem); if (!drm_dev_enter(from_pvr_device(pvr_dev), &idx)) { err = -EIO; goto err_up_read; } cmd.cmd_type = ROGUE_FWIF_KCCB_CMD_LOGTYPE_UPDATE; cmd.kccb_flags = 0; err = pvr_kccb_send_cmd(pvr_dev, &cmd, NULL); drm_dev_exit(idx); err_up_read: up_read(&pvr_dev->reset_sem); return err; } struct pvr_fw_trace_seq_data { /** @buffer: Pointer to copy of trace data. */ u32 *buffer; /** @start_offset: Starting offset in trace data, as reported by FW. */ u32 start_offset; /** @idx: Current index into trace data. */ u32 idx; /** @assert_buf: Trace assert buffer, as reported by FW. */ struct rogue_fwif_file_info_buf assert_buf; }; static u32 find_sfid(u32 id) { u32 i; for (i = 0; i < ARRAY_SIZE(stid_fmts); i++) { if (stid_fmts[i].id == id) return i; } return ROGUE_FW_SF_LAST; } static u32 read_fw_trace(struct pvr_fw_trace_seq_data *trace_seq_data, u32 offset) { u32 idx; idx = trace_seq_data->idx + offset; if (idx >= ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) return 0; idx = (idx + trace_seq_data->start_offset) % ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS; return trace_seq_data->buffer[idx]; } /** * fw_trace_get_next() - Advance trace index to next entry * @trace_seq_data: Trace sequence data. * * Returns: * * %true if trace index is now pointing to a valid entry, or * * %false if trace index is pointing to an invalid entry, or has hit the end * of the trace. */ static bool fw_trace_get_next(struct pvr_fw_trace_seq_data *trace_seq_data) { u32 id, sf_id; while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) { id = read_fw_trace(trace_seq_data, 0); trace_seq_data->idx++; if (!ROGUE_FW_LOG_VALIDID(id)) continue; if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) { /* Assertion failure marks the end of the trace. */ return false; } sf_id = find_sfid(id); if (sf_id == ROGUE_FW_SF_FIRST) continue; if (sf_id == ROGUE_FW_SF_LAST) { /* * Could not match with an ID in the SF table, trace is * most likely corrupt from this point. */ return false; } /* Skip over the timestamp, and any parameters. */ trace_seq_data->idx += 2 + ROGUE_FW_SF_PARAMNUM(id); /* Ensure index is now pointing to a valid trace entry. */ id = read_fw_trace(trace_seq_data, 0); if (!ROGUE_FW_LOG_VALIDID(id)) continue; return true; } /* Hit end of trace data. */ return false; } /** * fw_trace_get_first() - Find first valid entry in trace * @trace_seq_data: Trace sequence data. * * Skips over invalid (usually zero) and ROGUE_FW_SF_FIRST entries. * * If the trace has no valid entries, this function will exit with the trace * index pointing to the end of the trace. trace_seq_show() will return an error * in this state. */ static void fw_trace_get_first(struct pvr_fw_trace_seq_data *trace_seq_data) { trace_seq_data->idx = 0; while (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) { u32 id = read_fw_trace(trace_seq_data, 0); if (ROGUE_FW_LOG_VALIDID(id)) { u32 sf_id = find_sfid(id); if (sf_id != ROGUE_FW_SF_FIRST) break; } trace_seq_data->idx++; } } static void *fw_trace_seq_start(struct seq_file *s, loff_t *pos) { struct pvr_fw_trace_seq_data *trace_seq_data = s->private; u32 i; /* Reset trace index, then advance to *pos. */ fw_trace_get_first(trace_seq_data); for (i = 0; i < *pos; i++) { if (!fw_trace_get_next(trace_seq_data)) return NULL; } return (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) ? pos : NULL; } static void *fw_trace_seq_next(struct seq_file *s, void *v, loff_t *pos) { struct pvr_fw_trace_seq_data *trace_seq_data = s->private; (*pos)++; if (!fw_trace_get_next(trace_seq_data)) return NULL; return (trace_seq_data->idx < ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) ? pos : NULL; } static void fw_trace_seq_stop(struct seq_file *s, void *v) { } static int fw_trace_seq_show(struct seq_file *s, void *v) { struct pvr_fw_trace_seq_data *trace_seq_data = s->private; u64 timestamp; u32 id; u32 sf_id; if (trace_seq_data->idx >= ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS) return -EINVAL; id = read_fw_trace(trace_seq_data, 0); /* Index is not pointing at a valid entry. */ if (!ROGUE_FW_LOG_VALIDID(id)) return -EINVAL; sf_id = find_sfid(id); /* Index is not pointing at a valid entry. */ if (sf_id == ROGUE_FW_SF_LAST) return -EINVAL; timestamp = read_fw_trace(trace_seq_data, 1) | ((u64)read_fw_trace(trace_seq_data, 2) << 32); timestamp = (timestamp & ~ROGUE_FWT_TIMESTAMP_TIME_CLRMSK) >> ROGUE_FWT_TIMESTAMP_TIME_SHIFT; seq_printf(s, "[%llu] : ", timestamp); if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) { seq_printf(s, "ASSERTION %s failed at %s:%u", trace_seq_data->assert_buf.info, trace_seq_data->assert_buf.path, trace_seq_data->assert_buf.line_num); } else { seq_printf(s, stid_fmts[sf_id].name, read_fw_trace(trace_seq_data, 3), read_fw_trace(trace_seq_data, 4), read_fw_trace(trace_seq_data, 5), read_fw_trace(trace_seq_data, 6), read_fw_trace(trace_seq_data, 7), read_fw_trace(trace_seq_data, 8), read_fw_trace(trace_seq_data, 9), read_fw_trace(trace_seq_data, 10), read_fw_trace(trace_seq_data, 11), read_fw_trace(trace_seq_data, 12), read_fw_trace(trace_seq_data, 13), read_fw_trace(trace_seq_data, 14), read_fw_trace(trace_seq_data, 15), read_fw_trace(trace_seq_data, 16), read_fw_trace(trace_seq_data, 17), read_fw_trace(trace_seq_data, 18), read_fw_trace(trace_seq_data, 19), read_fw_trace(trace_seq_data, 20), read_fw_trace(trace_seq_data, 21), read_fw_trace(trace_seq_data, 22)); } seq_puts(s, "\n"); return 0; } static const struct seq_operations pvr_fw_trace_seq_ops = { .start = fw_trace_seq_start, .next = fw_trace_seq_next, .stop = fw_trace_seq_stop, .show = fw_trace_seq_show }; static int fw_trace_open(struct inode *inode, struct file *file) { struct pvr_fw_trace_buffer *trace_buffer = inode->i_private; struct rogue_fwif_tracebuf_space *tracebuf_space = trace_buffer->tracebuf_space; struct pvr_fw_trace_seq_data *trace_seq_data; int err; trace_seq_data = kzalloc(sizeof(*trace_seq_data), GFP_KERNEL); if (!trace_seq_data) return -ENOMEM; trace_seq_data->buffer = kcalloc(ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS, sizeof(*trace_seq_data->buffer), GFP_KERNEL); if (!trace_seq_data->buffer) { err = -ENOMEM; goto err_free_data; } /* * Take a local copy of the trace buffer, as firmware may still be * writing to it. This will exist as long as this file is open. */ memcpy(trace_seq_data->buffer, trace_buffer->buf, ROGUE_FW_TRACE_BUF_DEFAULT_SIZE_IN_DWORDS * sizeof(u32)); trace_seq_data->start_offset = READ_ONCE(tracebuf_space->trace_pointer); trace_seq_data->assert_buf = tracebuf_space->assert_buf; fw_trace_get_first(trace_seq_data); err = seq_open(file, &pvr_fw_trace_seq_ops); if (err) goto err_free_buffer; ((struct seq_file *)file->private_data)->private = trace_seq_data; return 0; err_free_buffer: kfree(trace_seq_data->buffer); err_free_data: kfree(trace_seq_data); return err; } static int fw_trace_release(struct inode *inode, struct file *file) { struct pvr_fw_trace_seq_data *trace_seq_data = ((struct seq_file *)file->private_data)->private; seq_release(inode, file); kfree(trace_seq_data->buffer); kfree(trace_seq_data); return 0; } static const struct file_operations pvr_fw_trace_fops = { .owner = THIS_MODULE, .open = fw_trace_open, .read = seq_read, .llseek = seq_lseek, .release = fw_trace_release, }; void pvr_fw_trace_mask_update(struct pvr_device *pvr_dev, u32 old_mask, u32 new_mask) { if (old_mask != new_mask) update_logtype(pvr_dev, new_mask); } void pvr_fw_trace_debugfs_init(struct pvr_device *pvr_dev, struct dentry *dir) { struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace; u32 thread_nr; static_assert(ARRAY_SIZE(fw_trace->buffers) <= 10, "The filename buffer is only large enough for a single-digit thread count"); for (thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); ++thread_nr) { char filename[8]; snprintf(filename, ARRAY_SIZE(filename), "trace_%u", thread_nr); debugfs_create_file(filename, 0400, dir, &fw_trace->buffers[thread_nr], &pvr_fw_trace_fops); } } #endif
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1