1 // SPDX-License-Identifier: MIT
2 /*
3 * Copyright © 2014-2019 Intel Corporation
4 */
5
6 #include <linux/debugfs.h>
7
8 #include "gt/intel_gt.h"
9 #include "i915_drv.h"
10 #include "i915_memcpy.h"
11 #include "intel_guc_log.h"
12
13 static void guc_log_capture_logs(struct intel_guc_log *log);
14
15 /**
16 * DOC: GuC firmware log
17 *
18 * Firmware log is enabled by setting i915.guc_log_level to the positive level.
19 * Log data is printed out via reading debugfs i915_guc_log_dump. Reading from
20 * i915_guc_load_status will print out firmware loading status and scratch
21 * registers value.
22 */
23
guc_action_flush_log_complete(struct intel_guc * guc)24 static int guc_action_flush_log_complete(struct intel_guc *guc)
25 {
26 u32 action[] = {
27 INTEL_GUC_ACTION_LOG_BUFFER_FILE_FLUSH_COMPLETE
28 };
29
30 return intel_guc_send(guc, action, ARRAY_SIZE(action));
31 }
32
guc_action_flush_log(struct intel_guc * guc)33 static int guc_action_flush_log(struct intel_guc *guc)
34 {
35 u32 action[] = {
36 INTEL_GUC_ACTION_FORCE_LOG_BUFFER_FLUSH,
37 0
38 };
39
40 return intel_guc_send(guc, action, ARRAY_SIZE(action));
41 }
42
guc_action_control_log(struct intel_guc * guc,bool enable,bool default_logging,u32 verbosity)43 static int guc_action_control_log(struct intel_guc *guc, bool enable,
44 bool default_logging, u32 verbosity)
45 {
46 u32 action[] = {
47 INTEL_GUC_ACTION_UK_LOG_ENABLE_LOGGING,
48 (enable ? GUC_LOG_CONTROL_LOGGING_ENABLED : 0) |
49 (verbosity << GUC_LOG_CONTROL_VERBOSITY_SHIFT) |
50 (default_logging ? GUC_LOG_CONTROL_DEFAULT_LOGGING : 0)
51 };
52
53 GEM_BUG_ON(verbosity > GUC_LOG_VERBOSITY_MAX);
54
55 return intel_guc_send(guc, action, ARRAY_SIZE(action));
56 }
57
guc_log_enable_flush_events(struct intel_guc_log * log)58 static void guc_log_enable_flush_events(struct intel_guc_log *log)
59 {
60 intel_guc_enable_msg(log_to_guc(log),
61 INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
62 INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED);
63 }
64
guc_log_disable_flush_events(struct intel_guc_log * log)65 static void guc_log_disable_flush_events(struct intel_guc_log *log)
66 {
67 intel_guc_disable_msg(log_to_guc(log),
68 INTEL_GUC_RECV_MSG_FLUSH_LOG_BUFFER |
69 INTEL_GUC_RECV_MSG_CRASH_DUMP_POSTED);
70 }
71
72 /*
73 * Sub buffer switch callback. Called whenever relay has to switch to a new
74 * sub buffer, relay stays on the same sub buffer if 0 is returned.
75 */
subbuf_start_callback(struct rchan_buf * buf,void * subbuf,void * prev_subbuf,size_t prev_padding)76 static int subbuf_start_callback(struct rchan_buf *buf,
77 void *subbuf,
78 void *prev_subbuf,
79 size_t prev_padding)
80 {
81 /*
82 * Use no-overwrite mode by default, where relay will stop accepting
83 * new data if there are no empty sub buffers left.
84 * There is no strict synchronization enforced by relay between Consumer
85 * and Producer. In overwrite mode, there is a possibility of getting
86 * inconsistent/garbled data, the producer could be writing on to the
87 * same sub buffer from which Consumer is reading. This can't be avoided
88 * unless Consumer is fast enough and can always run in tandem with
89 * Producer.
90 */
91 if (relay_buf_full(buf))
92 return 0;
93
94 return 1;
95 }
96
97 /*
98 * file_create() callback. Creates relay file in debugfs.
99 */
create_buf_file_callback(const char * filename,struct dentry * parent,umode_t mode,struct rchan_buf * buf,int * is_global)100 static struct dentry *create_buf_file_callback(const char *filename,
101 struct dentry *parent,
102 umode_t mode,
103 struct rchan_buf *buf,
104 int *is_global)
105 {
106 struct dentry *buf_file;
107
108 /*
109 * This to enable the use of a single buffer for the relay channel and
110 * correspondingly have a single file exposed to User, through which
111 * it can collect the logs in order without any post-processing.
112 * Need to set 'is_global' even if parent is NULL for early logging.
113 */
114 *is_global = 1;
115
116 if (!parent)
117 return NULL;
118
119 buf_file = debugfs_create_file(filename, mode,
120 parent, buf, &relay_file_operations);
121 if (IS_ERR(buf_file))
122 return NULL;
123
124 return buf_file;
125 }
126
127 /*
128 * file_remove() default callback. Removes relay file in debugfs.
129 */
remove_buf_file_callback(struct dentry * dentry)130 static int remove_buf_file_callback(struct dentry *dentry)
131 {
132 debugfs_remove(dentry);
133 return 0;
134 }
135
136 /* relay channel callbacks */
137 static const struct rchan_callbacks relay_callbacks = {
138 .subbuf_start = subbuf_start_callback,
139 .create_buf_file = create_buf_file_callback,
140 .remove_buf_file = remove_buf_file_callback,
141 };
142
guc_move_to_next_buf(struct intel_guc_log * log)143 static void guc_move_to_next_buf(struct intel_guc_log *log)
144 {
145 /*
146 * Make sure the updates made in the sub buffer are visible when
147 * Consumer sees the following update to offset inside the sub buffer.
148 */
149 smp_wmb();
150
151 /* All data has been written, so now move the offset of sub buffer. */
152 relay_reserve(log->relay.channel, log->vma->obj->base.size);
153
154 /* Switch to the next sub buffer */
155 relay_flush(log->relay.channel);
156 }
157
guc_get_write_buffer(struct intel_guc_log * log)158 static void *guc_get_write_buffer(struct intel_guc_log *log)
159 {
160 /*
161 * Just get the base address of a new sub buffer and copy data into it
162 * ourselves. NULL will be returned in no-overwrite mode, if all sub
163 * buffers are full. Could have used the relay_write() to indirectly
164 * copy the data, but that would have been bit convoluted, as we need to
165 * write to only certain locations inside a sub buffer which cannot be
166 * done without using relay_reserve() along with relay_write(). So its
167 * better to use relay_reserve() alone.
168 */
169 return relay_reserve(log->relay.channel, 0);
170 }
171
guc_check_log_buf_overflow(struct intel_guc_log * log,enum guc_log_buffer_type type,unsigned int full_cnt)172 static bool guc_check_log_buf_overflow(struct intel_guc_log *log,
173 enum guc_log_buffer_type type,
174 unsigned int full_cnt)
175 {
176 unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
177 bool overflow = false;
178
179 if (full_cnt != prev_full_cnt) {
180 overflow = true;
181
182 log->stats[type].overflow = full_cnt;
183 log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;
184
185 if (full_cnt < prev_full_cnt) {
186 /* buffer_full_cnt is a 4 bit counter */
187 log->stats[type].sampled_overflow += 16;
188 }
189
190 dev_notice_ratelimited(guc_to_gt(log_to_guc(log))->i915->drm.dev,
191 "GuC log buffer overflow\n");
192 }
193
194 return overflow;
195 }
196
guc_get_log_buffer_size(enum guc_log_buffer_type type)197 static unsigned int guc_get_log_buffer_size(enum guc_log_buffer_type type)
198 {
199 switch (type) {
200 case GUC_DEBUG_LOG_BUFFER:
201 return DEBUG_BUFFER_SIZE;
202 case GUC_CRASH_DUMP_LOG_BUFFER:
203 return CRASH_BUFFER_SIZE;
204 default:
205 MISSING_CASE(type);
206 }
207
208 return 0;
209 }
210
guc_read_update_log_buffer(struct intel_guc_log * log)211 static void guc_read_update_log_buffer(struct intel_guc_log *log)
212 {
213 unsigned int buffer_size, read_offset, write_offset, bytes_to_copy, full_cnt;
214 struct guc_log_buffer_state *log_buf_state, *log_buf_snapshot_state;
215 struct guc_log_buffer_state log_buf_state_local;
216 enum guc_log_buffer_type type;
217 void *src_data, *dst_data;
218 bool new_overflow;
219
220 mutex_lock(&log->relay.lock);
221
222 if (WARN_ON(!intel_guc_log_relay_created(log)))
223 goto out_unlock;
224
225 /* Get the pointer to shared GuC log buffer */
226 log_buf_state = src_data = log->relay.buf_addr;
227
228 /* Get the pointer to local buffer to store the logs */
229 log_buf_snapshot_state = dst_data = guc_get_write_buffer(log);
230
231 if (unlikely(!log_buf_snapshot_state)) {
232 /*
233 * Used rate limited to avoid deluge of messages, logs might be
234 * getting consumed by User at a slow rate.
235 */
236 DRM_ERROR_RATELIMITED("no sub-buffer to capture logs\n");
237 log->relay.full_count++;
238
239 goto out_unlock;
240 }
241
242 /* Actual logs are present from the 2nd page */
243 src_data += PAGE_SIZE;
244 dst_data += PAGE_SIZE;
245
246 for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
247 /*
248 * Make a copy of the state structure, inside GuC log buffer
249 * (which is uncached mapped), on the stack to avoid reading
250 * from it multiple times.
251 */
252 memcpy(&log_buf_state_local, log_buf_state,
253 sizeof(struct guc_log_buffer_state));
254 buffer_size = guc_get_log_buffer_size(type);
255 read_offset = log_buf_state_local.read_ptr;
256 write_offset = log_buf_state_local.sampled_write_ptr;
257 full_cnt = log_buf_state_local.buffer_full_cnt;
258
259 /* Bookkeeping stuff */
260 log->stats[type].flush += log_buf_state_local.flush_to_file;
261 new_overflow = guc_check_log_buf_overflow(log, type, full_cnt);
262
263 /* Update the state of shared log buffer */
264 log_buf_state->read_ptr = write_offset;
265 log_buf_state->flush_to_file = 0;
266 log_buf_state++;
267
268 /* First copy the state structure in snapshot buffer */
269 memcpy(log_buf_snapshot_state, &log_buf_state_local,
270 sizeof(struct guc_log_buffer_state));
271
272 /*
273 * The write pointer could have been updated by GuC firmware,
274 * after sending the flush interrupt to Host, for consistency
275 * set write pointer value to same value of sampled_write_ptr
276 * in the snapshot buffer.
277 */
278 log_buf_snapshot_state->write_ptr = write_offset;
279 log_buf_snapshot_state++;
280
281 /* Now copy the actual logs. */
282 if (unlikely(new_overflow)) {
283 /* copy the whole buffer in case of overflow */
284 read_offset = 0;
285 write_offset = buffer_size;
286 } else if (unlikely((read_offset > buffer_size) ||
287 (write_offset > buffer_size))) {
288 DRM_ERROR("invalid log buffer state\n");
289 /* copy whole buffer as offsets are unreliable */
290 read_offset = 0;
291 write_offset = buffer_size;
292 }
293
294 /* Just copy the newly written data */
295 if (read_offset > write_offset) {
296 i915_memcpy_from_wc(dst_data, src_data, write_offset);
297 bytes_to_copy = buffer_size - read_offset;
298 } else {
299 bytes_to_copy = write_offset - read_offset;
300 }
301 i915_memcpy_from_wc(dst_data + read_offset,
302 src_data + read_offset, bytes_to_copy);
303
304 src_data += buffer_size;
305 dst_data += buffer_size;
306 }
307
308 guc_move_to_next_buf(log);
309
310 out_unlock:
311 mutex_unlock(&log->relay.lock);
312 }
313
capture_logs_work(struct work_struct * work)314 static void capture_logs_work(struct work_struct *work)
315 {
316 struct intel_guc_log *log =
317 container_of(work, struct intel_guc_log, relay.flush_work);
318
319 guc_log_capture_logs(log);
320 }
321
guc_log_map(struct intel_guc_log * log)322 static int guc_log_map(struct intel_guc_log *log)
323 {
324 void *vaddr;
325
326 lockdep_assert_held(&log->relay.lock);
327
328 if (!log->vma)
329 return -ENODEV;
330
331 /*
332 * Create a WC (Uncached for read) vmalloc mapping of log
333 * buffer pages, so that we can directly get the data
334 * (up-to-date) from memory.
335 */
336 vaddr = i915_gem_object_pin_map_unlocked(log->vma->obj, I915_MAP_WC);
337 if (IS_ERR(vaddr))
338 return PTR_ERR(vaddr);
339
340 log->relay.buf_addr = vaddr;
341
342 return 0;
343 }
344
guc_log_unmap(struct intel_guc_log * log)345 static void guc_log_unmap(struct intel_guc_log *log)
346 {
347 lockdep_assert_held(&log->relay.lock);
348
349 i915_gem_object_unpin_map(log->vma->obj);
350 log->relay.buf_addr = NULL;
351 }
352
intel_guc_log_init_early(struct intel_guc_log * log)353 void intel_guc_log_init_early(struct intel_guc_log *log)
354 {
355 mutex_init(&log->relay.lock);
356 INIT_WORK(&log->relay.flush_work, capture_logs_work);
357 log->relay.started = false;
358 }
359
guc_log_relay_create(struct intel_guc_log * log)360 static int guc_log_relay_create(struct intel_guc_log *log)
361 {
362 struct intel_guc *guc = log_to_guc(log);
363 struct drm_i915_private *dev_priv = guc_to_gt(guc)->i915;
364 struct rchan *guc_log_relay_chan;
365 size_t n_subbufs, subbuf_size;
366 int ret;
367
368 lockdep_assert_held(&log->relay.lock);
369 GEM_BUG_ON(!log->vma);
370
371 /* Keep the size of sub buffers same as shared log buffer */
372 subbuf_size = log->vma->size;
373
374 /*
375 * Store up to 8 snapshots, which is large enough to buffer sufficient
376 * boot time logs and provides enough leeway to User, in terms of
377 * latency, for consuming the logs from relay. Also doesn't take
378 * up too much memory.
379 */
380 n_subbufs = 8;
381
382 guc_log_relay_chan = relay_open("guc_log",
383 dev_priv->drm.primary->debugfs_root,
384 subbuf_size, n_subbufs,
385 &relay_callbacks, dev_priv);
386 if (!guc_log_relay_chan) {
387 DRM_ERROR("Couldn't create relay chan for GuC logging\n");
388
389 ret = -ENOMEM;
390 return ret;
391 }
392
393 GEM_BUG_ON(guc_log_relay_chan->subbuf_size < subbuf_size);
394 log->relay.channel = guc_log_relay_chan;
395
396 return 0;
397 }
398
guc_log_relay_destroy(struct intel_guc_log * log)399 static void guc_log_relay_destroy(struct intel_guc_log *log)
400 {
401 lockdep_assert_held(&log->relay.lock);
402
403 relay_close(log->relay.channel);
404 log->relay.channel = NULL;
405 }
406
guc_log_capture_logs(struct intel_guc_log * log)407 static void guc_log_capture_logs(struct intel_guc_log *log)
408 {
409 struct intel_guc *guc = log_to_guc(log);
410 struct drm_i915_private *dev_priv = guc_to_gt(guc)->i915;
411 intel_wakeref_t wakeref;
412
413 guc_read_update_log_buffer(log);
414
415 /*
416 * Generally device is expected to be active only at this
417 * time, so get/put should be really quick.
418 */
419 with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)
420 guc_action_flush_log_complete(guc);
421 }
422
__get_default_log_level(struct intel_guc_log * log)423 static u32 __get_default_log_level(struct intel_guc_log *log)
424 {
425 struct intel_guc *guc = log_to_guc(log);
426 struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
427
428 /* A negative value means "use platform/config default" */
429 if (i915->params.guc_log_level < 0) {
430 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
431 IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ?
432 GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_NON_VERBOSE;
433 }
434
435 if (i915->params.guc_log_level > GUC_LOG_LEVEL_MAX) {
436 DRM_WARN("Incompatible option detected: %s=%d, %s!\n",
437 "guc_log_level", i915->params.guc_log_level,
438 "verbosity too high");
439 return (IS_ENABLED(CONFIG_DRM_I915_DEBUG) ||
440 IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) ?
441 GUC_LOG_LEVEL_MAX : GUC_LOG_LEVEL_DISABLED;
442 }
443
444 GEM_BUG_ON(i915->params.guc_log_level < GUC_LOG_LEVEL_DISABLED);
445 GEM_BUG_ON(i915->params.guc_log_level > GUC_LOG_LEVEL_MAX);
446 return i915->params.guc_log_level;
447 }
448
intel_guc_log_create(struct intel_guc_log * log)449 int intel_guc_log_create(struct intel_guc_log *log)
450 {
451 struct intel_guc *guc = log_to_guc(log);
452 struct i915_vma *vma;
453 u32 guc_log_size;
454 int ret;
455
456 GEM_BUG_ON(log->vma);
457
458 /*
459 * GuC Log buffer Layout
460 *
461 * +===============================+ 00B
462 * | Crash dump state header |
463 * +-------------------------------+ 32B
464 * | Debug state header |
465 * +-------------------------------+ 64B
466 * | |
467 * +===============================+ PAGE_SIZE (4KB)
468 * | Crash Dump logs |
469 * +===============================+ + CRASH_SIZE
470 * | Debug logs |
471 * +===============================+ + DEBUG_SIZE
472 */
473 guc_log_size = PAGE_SIZE + CRASH_BUFFER_SIZE + DEBUG_BUFFER_SIZE;
474
475 vma = intel_guc_allocate_vma(guc, guc_log_size);
476 if (IS_ERR(vma)) {
477 ret = PTR_ERR(vma);
478 goto err;
479 }
480
481 log->vma = vma;
482
483 log->level = __get_default_log_level(log);
484 DRM_DEBUG_DRIVER("guc_log_level=%d (%s, verbose:%s, verbosity:%d)\n",
485 log->level, enableddisabled(log->level),
486 yesno(GUC_LOG_LEVEL_IS_VERBOSE(log->level)),
487 GUC_LOG_LEVEL_TO_VERBOSITY(log->level));
488
489 return 0;
490
491 err:
492 DRM_ERROR("Failed to allocate GuC log buffer. %d\n", ret);
493 return ret;
494 }
495
intel_guc_log_destroy(struct intel_guc_log * log)496 void intel_guc_log_destroy(struct intel_guc_log *log)
497 {
498 i915_vma_unpin_and_release(&log->vma, 0);
499 }
500
intel_guc_log_set_level(struct intel_guc_log * log,u32 level)501 int intel_guc_log_set_level(struct intel_guc_log *log, u32 level)
502 {
503 struct intel_guc *guc = log_to_guc(log);
504 struct drm_i915_private *dev_priv = guc_to_gt(guc)->i915;
505 intel_wakeref_t wakeref;
506 int ret = 0;
507
508 BUILD_BUG_ON(GUC_LOG_VERBOSITY_MIN != 0);
509 GEM_BUG_ON(!log->vma);
510
511 /*
512 * GuC is recognizing log levels starting from 0 to max, we're using 0
513 * as indication that logging should be disabled.
514 */
515 if (level < GUC_LOG_LEVEL_DISABLED || level > GUC_LOG_LEVEL_MAX)
516 return -EINVAL;
517
518 mutex_lock(&dev_priv->drm.struct_mutex);
519
520 if (log->level == level)
521 goto out_unlock;
522
523 with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)
524 ret = guc_action_control_log(guc,
525 GUC_LOG_LEVEL_IS_VERBOSE(level),
526 GUC_LOG_LEVEL_IS_ENABLED(level),
527 GUC_LOG_LEVEL_TO_VERBOSITY(level));
528 if (ret) {
529 DRM_DEBUG_DRIVER("guc_log_control action failed %d\n", ret);
530 goto out_unlock;
531 }
532
533 log->level = level;
534
535 out_unlock:
536 mutex_unlock(&dev_priv->drm.struct_mutex);
537
538 return ret;
539 }
540
intel_guc_log_relay_created(const struct intel_guc_log * log)541 bool intel_guc_log_relay_created(const struct intel_guc_log *log)
542 {
543 return log->relay.buf_addr;
544 }
545
intel_guc_log_relay_open(struct intel_guc_log * log)546 int intel_guc_log_relay_open(struct intel_guc_log *log)
547 {
548 int ret;
549
550 if (!log->vma)
551 return -ENODEV;
552
553 mutex_lock(&log->relay.lock);
554
555 if (intel_guc_log_relay_created(log)) {
556 ret = -EEXIST;
557 goto out_unlock;
558 }
559
560 /*
561 * We require SSE 4.1 for fast reads from the GuC log buffer and
562 * it should be present on the chipsets supporting GuC based
563 * submisssions.
564 */
565 if (!i915_has_memcpy_from_wc()) {
566 ret = -ENXIO;
567 goto out_unlock;
568 }
569
570 ret = guc_log_relay_create(log);
571 if (ret)
572 goto out_unlock;
573
574 ret = guc_log_map(log);
575 if (ret)
576 goto out_relay;
577
578 mutex_unlock(&log->relay.lock);
579
580 return 0;
581
582 out_relay:
583 guc_log_relay_destroy(log);
584 out_unlock:
585 mutex_unlock(&log->relay.lock);
586
587 return ret;
588 }
589
intel_guc_log_relay_start(struct intel_guc_log * log)590 int intel_guc_log_relay_start(struct intel_guc_log *log)
591 {
592 if (log->relay.started)
593 return -EEXIST;
594
595 guc_log_enable_flush_events(log);
596
597 /*
598 * When GuC is logging without us relaying to userspace, we're ignoring
599 * the flush notification. This means that we need to unconditionally
600 * flush on relay enabling, since GuC only notifies us once.
601 */
602 queue_work(system_highpri_wq, &log->relay.flush_work);
603
604 log->relay.started = true;
605
606 return 0;
607 }
608
intel_guc_log_relay_flush(struct intel_guc_log * log)609 void intel_guc_log_relay_flush(struct intel_guc_log *log)
610 {
611 struct intel_guc *guc = log_to_guc(log);
612 intel_wakeref_t wakeref;
613
614 if (!log->relay.started)
615 return;
616
617 /*
618 * Before initiating the forceful flush, wait for any pending/ongoing
619 * flush to complete otherwise forceful flush may not actually happen.
620 */
621 flush_work(&log->relay.flush_work);
622
623 with_intel_runtime_pm(guc_to_gt(guc)->uncore->rpm, wakeref)
624 guc_action_flush_log(guc);
625
626 /* GuC would have updated log buffer by now, so capture it */
627 guc_log_capture_logs(log);
628 }
629
630 /*
631 * Stops the relay log. Called from intel_guc_log_relay_close(), so no
632 * possibility of race with start/flush since relay_write cannot race
633 * relay_close.
634 */
guc_log_relay_stop(struct intel_guc_log * log)635 static void guc_log_relay_stop(struct intel_guc_log *log)
636 {
637 struct intel_guc *guc = log_to_guc(log);
638 struct drm_i915_private *i915 = guc_to_gt(guc)->i915;
639
640 if (!log->relay.started)
641 return;
642
643 guc_log_disable_flush_events(log);
644 intel_synchronize_irq(i915);
645
646 flush_work(&log->relay.flush_work);
647
648 log->relay.started = false;
649 }
650
intel_guc_log_relay_close(struct intel_guc_log * log)651 void intel_guc_log_relay_close(struct intel_guc_log *log)
652 {
653 guc_log_relay_stop(log);
654
655 mutex_lock(&log->relay.lock);
656 GEM_BUG_ON(!intel_guc_log_relay_created(log));
657 guc_log_unmap(log);
658 guc_log_relay_destroy(log);
659 mutex_unlock(&log->relay.lock);
660 }
661
intel_guc_log_handle_flush_event(struct intel_guc_log * log)662 void intel_guc_log_handle_flush_event(struct intel_guc_log *log)
663 {
664 queue_work(system_highpri_wq, &log->relay.flush_work);
665 }
666
667 static const char *
stringify_guc_log_type(enum guc_log_buffer_type type)668 stringify_guc_log_type(enum guc_log_buffer_type type)
669 {
670 switch (type) {
671 case GUC_DEBUG_LOG_BUFFER:
672 return "DEBUG";
673 case GUC_CRASH_DUMP_LOG_BUFFER:
674 return "CRASH";
675 default:
676 MISSING_CASE(type);
677 }
678
679 return "";
680 }
681
682 /**
683 * intel_guc_log_info - dump information about GuC log relay
684 * @log: the GuC log
685 * @p: the &drm_printer
686 *
687 * Pretty printer for GuC log info
688 */
intel_guc_log_info(struct intel_guc_log * log,struct drm_printer * p)689 void intel_guc_log_info(struct intel_guc_log *log, struct drm_printer *p)
690 {
691 enum guc_log_buffer_type type;
692
693 if (!intel_guc_log_relay_created(log)) {
694 drm_puts(p, "GuC log relay not created\n");
695 return;
696 }
697
698 drm_puts(p, "GuC logging stats:\n");
699
700 drm_printf(p, "\tRelay full count: %u\n", log->relay.full_count);
701
702 for (type = GUC_DEBUG_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
703 drm_printf(p, "\t%s:\tflush count %10u, overflow count %10u\n",
704 stringify_guc_log_type(type),
705 log->stats[type].flush,
706 log->stats[type].sampled_overflow);
707 }
708 }
709
710 /**
711 * intel_guc_log_dump - dump the contents of the GuC log
712 * @log: the GuC log
713 * @p: the &drm_printer
714 * @dump_load_err: dump the log saved on GuC load error
715 *
716 * Pretty printer for the GuC log
717 */
intel_guc_log_dump(struct intel_guc_log * log,struct drm_printer * p,bool dump_load_err)718 int intel_guc_log_dump(struct intel_guc_log *log, struct drm_printer *p,
719 bool dump_load_err)
720 {
721 struct intel_guc *guc = log_to_guc(log);
722 struct intel_uc *uc = container_of(guc, struct intel_uc, guc);
723 struct drm_i915_gem_object *obj = NULL;
724 u32 *map;
725 int i = 0;
726
727 if (!intel_guc_is_supported(guc))
728 return -ENODEV;
729
730 if (dump_load_err)
731 obj = uc->load_err_log;
732 else if (guc->log.vma)
733 obj = guc->log.vma->obj;
734
735 if (!obj)
736 return 0;
737
738 map = i915_gem_object_pin_map_unlocked(obj, I915_MAP_WC);
739 if (IS_ERR(map)) {
740 DRM_DEBUG("Failed to pin object\n");
741 drm_puts(p, "(log data unaccessible)\n");
742 return PTR_ERR(map);
743 }
744
745 for (i = 0; i < obj->base.size / sizeof(u32); i += 4)
746 drm_printf(p, "0x%08x 0x%08x 0x%08x 0x%08x\n",
747 *(map + i), *(map + i + 1),
748 *(map + i + 2), *(map + i + 3));
749
750 drm_puts(p, "\n");
751
752 i915_gem_object_unpin_map(obj);
753
754 return 0;
755 }
756