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#include <drm/drm_print.h>
13
14#include <linux/build_bug.h>
15#include <linux/dcache.h>
16#include <linux/debugfs.h>
17#include <linux/sysfs.h>
18#include <linux/types.h>
19
20static void
21tracebuf_ctrl_init(void *cpu_ptr, void *priv)
22{
23 struct rogue_fwif_tracebuf *tracebuf_ctrl = cpu_ptr;
24 struct pvr_fw_trace *fw_trace = priv;
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 (u32 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(fw_obj: trace_buffer->buf_obj,
40 fw_addr_out: &tracebuf_space->trace_buffer_fw_addr);
41
42 tracebuf_space->trace_buffer = trace_buffer->buf;
43 tracebuf_space->trace_pointer = 0;
44 }
45}
46
47int 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 int err;
52
53 for (u32 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, pvr_obj_out: &trace_buffer->buf_obj);
63 if (IS_ERR(ptr: trace_buffer->buf)) {
64 drm_err(drm_dev, "Unable to allocate trace buffer\n");
65 err = PTR_ERR(ptr: 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 size: sizeof(*fw_trace->tracebuf_ctrl),
77 PVR_BO_FW_FLAGS_DEVICE_UNCACHED |
78 PVR_BO_FW_NO_CLEAR_ON_RESET,
79 init: tracebuf_ctrl_init, init_priv: fw_trace,
80 pvr_obj_out: &fw_trace->tracebuf_ctrl_obj);
81 if (IS_ERR(ptr: fw_trace->tracebuf_ctrl)) {
82 drm_err(drm_dev, "Unable to allocate trace buffer control structure\n");
83 err = PTR_ERR(ptr: 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 (u32 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
100err_free_buf:
101 for (u32 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(fw_obj: trace_buffer->buf_obj);
106 }
107
108 return err;
109}
110
111void pvr_fw_trace_fini(struct pvr_device *pvr_dev)
112{
113 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace;
114
115 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); thread_nr++) {
116 struct pvr_fw_trace_buffer *trace_buffer = &fw_trace->buffers[thread_nr];
117
118 pvr_fw_object_unmap_and_destroy(fw_obj: trace_buffer->buf_obj);
119 }
120 pvr_fw_object_unmap_and_destroy(fw_obj: fw_trace->tracebuf_ctrl_obj);
121}
122
123/**
124 * update_logtype() - Send KCCB command to trigger FW to update logtype
125 * @pvr_dev: Target PowerVR device
126 * @group_mask: New log group mask.
127 *
128 * Returns:
129 * * 0 on success,
130 * * Any error returned by pvr_kccb_send_cmd(), or
131 * * -%EIO if the device is lost.
132 */
133static int
134update_logtype(struct pvr_device *pvr_dev, u32 group_mask)
135{
136 struct pvr_fw_trace *fw_trace = &pvr_dev->fw_dev.fw_trace;
137 struct rogue_fwif_kccb_cmd cmd;
138 int idx;
139 int err;
140 int slot;
141
142 if (group_mask)
143 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_TRACE | group_mask;
144 else
145 fw_trace->tracebuf_ctrl->log_type = ROGUE_FWIF_LOG_TYPE_NONE;
146
147 fw_trace->group_mask = group_mask;
148
149 down_read(sem: &pvr_dev->reset_sem);
150 if (!drm_dev_enter(from_pvr_device(pvr_dev), idx: &idx)) {
151 err = -EIO;
152 goto err_up_read;
153 }
154
155 cmd.cmd_type = ROGUE_FWIF_KCCB_CMD_LOGTYPE_UPDATE;
156 cmd.kccb_flags = 0;
157
158 err = pvr_kccb_send_cmd(pvr_dev, cmd: &cmd, kccb_slot: &slot);
159 if (err)
160 goto err_drm_dev_exit;
161
162 err = pvr_kccb_wait_for_completion(pvr_dev, slot_nr: slot, HZ, NULL);
163
164err_drm_dev_exit:
165 drm_dev_exit(idx);
166
167err_up_read:
168 up_read(sem: &pvr_dev->reset_sem);
169
170 return err;
171}
172
173struct pvr_fw_trace_seq_data {
174 /** @buffer: Pointer to copy of trace data. */
175 u32 *buffer;
176
177 /** @start_offset: Starting offset in trace data, as reported by FW. */
178 u32 start_offset;
179
180 /** @idx: Current index into trace data. */
181 u32 idx;
182
183 /** @assert_buf: Trace assert buffer, as reported by FW. */
184 struct rogue_fwif_file_info_buf assert_buf;
185};
186
187static u32 find_sfid(u32 id)
188{
189 for (u32 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
197static 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 */
218static 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, offset: 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, offset: 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 */
268static 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, offset: 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
285static 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
289 /* Reset trace index, then advance to *pos. */
290 fw_trace_get_first(trace_seq_data);
291
292 for (u32 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
300static 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
311static void fw_trace_seq_stop(struct seq_file *s, void *v)
312{
313}
314
315static 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, offset: 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 = ((u64)read_fw_trace(trace_seq_data, offset: 1) << 32) |
336 read_fw_trace(trace_seq_data, offset: 2);
337 timestamp = (timestamp & ~ROGUE_FWT_TIMESTAMP_TIME_CLRMSK) >>
338 ROGUE_FWT_TIMESTAMP_TIME_SHIFT;
339
340 seq_printf(m: s, fmt: "[%llu] : ", timestamp);
341 if (id == ROGUE_FW_SF_MAIN_ASSERT_FAILED) {
342 seq_printf(m: s, fmt: "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(m: s, fmt: stid_fmts[sf_id].name,
348 read_fw_trace(trace_seq_data, offset: 3),
349 read_fw_trace(trace_seq_data, offset: 4),
350 read_fw_trace(trace_seq_data, offset: 5),
351 read_fw_trace(trace_seq_data, offset: 6),
352 read_fw_trace(trace_seq_data, offset: 7),
353 read_fw_trace(trace_seq_data, offset: 8),
354 read_fw_trace(trace_seq_data, offset: 9),
355 read_fw_trace(trace_seq_data, offset: 10),
356 read_fw_trace(trace_seq_data, offset: 11),
357 read_fw_trace(trace_seq_data, offset: 12),
358 read_fw_trace(trace_seq_data, offset: 13),
359 read_fw_trace(trace_seq_data, offset: 14),
360 read_fw_trace(trace_seq_data, offset: 15),
361 read_fw_trace(trace_seq_data, offset: 16),
362 read_fw_trace(trace_seq_data, offset: 17),
363 read_fw_trace(trace_seq_data, offset: 18),
364 read_fw_trace(trace_seq_data, offset: 19),
365 read_fw_trace(trace_seq_data, offset: 20),
366 read_fw_trace(trace_seq_data, offset: 21),
367 read_fw_trace(trace_seq_data, offset: 22));
368 }
369 seq_puts(m: s, s: "\n");
370 return 0;
371}
372
373static 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
380static 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
417err_free_buffer:
418 kfree(objp: trace_seq_data->buffer);
419
420err_free_data:
421 kfree(objp: trace_seq_data);
422
423 return err;
424}
425
426static 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(objp: trace_seq_data->buffer);
433 kfree(objp: trace_seq_data);
434
435 return 0;
436}
437
438static 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
446void
447pvr_fw_trace_mask_update(struct pvr_device *pvr_dev, u32 old_mask, u32 new_mask)
448{
449 if (IS_ENABLED(CONFIG_DEBUG_FS) && old_mask != new_mask)
450 update_logtype(pvr_dev, group_mask: new_mask);
451}
452
453void
454pvr_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
458 if (!IS_ENABLED(CONFIG_DEBUG_FS))
459 return;
460
461 static_assert(ARRAY_SIZE(fw_trace->buffers) <= 10,
462 "The filename buffer is only large enough for a single-digit thread count");
463
464 for (u32 thread_nr = 0; thread_nr < ARRAY_SIZE(fw_trace->buffers); ++thread_nr) {
465 char filename[8];
466
467 snprintf(buf: filename, ARRAY_SIZE(filename), fmt: "trace_%u", thread_nr);
468 debugfs_create_file(filename, 0400, dir,
469 &fw_trace->buffers[thread_nr],
470 &pvr_fw_trace_fops);
471 }
472}
473

source code of linux/drivers/gpu/drm/imagination/pvr_fw_trace.c