path: root/drivers/gpu/drm/xe/xe_guc_log.c

// SPDX-License-Identifier: MIT
/*
 * Copyright © 2022 Intel Corporation
 */

#include "xe_guc_log.h"

#include <linux/fault-inject.h>

#include <linux/utsname.h>
#include <drm/drm_managed.h>

#include "abi/guc_lfd_abi.h"
#include "regs/xe_guc_regs.h"
#include "xe_bo.h"
#include "xe_devcoredump.h"
#include "xe_force_wake.h"
#include "xe_gt_printk.h"
#include "xe_gt_types.h"
#include "xe_map.h"
#include "xe_mmio.h"
#include "xe_module.h"

#define GUC_LOG_CHUNK_SIZE			SZ_2M

/* Magic keys define */
#define GUC_LFD_DRIVER_KEY_STREAMING		0x8086AAAA474C5346
#define GUC_LFD_LOG_BUFFER_MARKER_2		0xDEADFEED
#define GUC_LFD_CRASH_DUMP_BUFFER_MARKER_2	0x8086DEAD
#define GUC_LFD_STATE_CAPTURE_BUFFER_MARKER_2	0xBEEFFEED
#define GUC_LFD_LOG_BUFFER_MARKER_1V2		0xCABBA9E6
#define GUC_LFD_STATE_CAPTURE_BUFFER_MARKER_1V2	0xCABBA9F7
#define GUC_LFD_DATA_HEADER_MAGIC		0x8086

/* LFD supported LIC type range */
#define GUC_LIC_TYPE_FIRST			GUC_LIC_TYPE_GUC_SW_VERSION
#define GUC_LIC_TYPE_LAST			GUC_LIC_TYPE_BUILD_PLATFORM_ID
#define GUC_LFD_TYPE_FW_RANGE_FIRST		GUC_LFD_TYPE_FW_VERSION
#define GUC_LFD_TYPE_FW_RANGE_LAST		GUC_LFD_TYPE_BUILD_PLATFORM_ID

#define GUC_LOG_BUFFER_STATE_HEADER_LENGTH	4096
#define GUC_LOG_BUFFER_INIT_CONFIG		3

struct guc_log_buffer_entry_list {
	u32 offset;
	u32 rd_ptr;
	u32 wr_ptr;
	u32 wrap_offset;
	u32 buf_size;
};

struct guc_lic_save {
	u32 version;
	/*
	 * Array of init config KLV values.
	 * Range from GUC_LOG_LIC_TYPE_FIRST to GUC_LOG_LIC_TYPE_LAST
	 */
	u32 values[GUC_LIC_TYPE_LAST - GUC_LIC_TYPE_FIRST + 1];
	struct guc_log_buffer_entry_list entry[GUC_LOG_BUFFER_INIT_CONFIG];
};

static struct guc_log_buffer_entry_markers {
	u32 key[2];
} const entry_markers[GUC_LOG_BUFFER_INIT_CONFIG + 1] = {
	{{
		GUC_LFD_LOG_BUFFER_MARKER_1V2,
		GUC_LFD_LOG_BUFFER_MARKER_2
	}},
	{{
		GUC_LFD_LOG_BUFFER_MARKER_1V2,
		GUC_LFD_CRASH_DUMP_BUFFER_MARKER_2
	}},
	{{
		GUC_LFD_STATE_CAPTURE_BUFFER_MARKER_1V2,
		GUC_LFD_STATE_CAPTURE_BUFFER_MARKER_2
	}},
	{{
		GUC_LIC_MAGIC,
		(FIELD_PREP_CONST(GUC_LIC_VERSION_MASK_MAJOR, GUC_LIC_VERSION_MAJOR) |
		 FIELD_PREP_CONST(GUC_LIC_VERSION_MASK_MINOR, GUC_LIC_VERSION_MINOR))
	}}
};

static struct guc_log_lic_lfd_map {
	u32 lic;
	u32 lfd;
} const lic_lfd_type_map[] = {
	{GUC_LIC_TYPE_GUC_SW_VERSION,		GUC_LFD_TYPE_FW_VERSION},
	{GUC_LIC_TYPE_GUC_DEVICE_ID,		GUC_LFD_TYPE_GUC_DEVICE_ID},
	{GUC_LIC_TYPE_TSC_FREQUENCY,		GUC_LFD_TYPE_TSC_FREQUENCY},
	{GUC_LIC_TYPE_GMD_ID,			GUC_LFD_TYPE_GMD_ID},
	{GUC_LIC_TYPE_BUILD_PLATFORM_ID,	GUC_LFD_TYPE_BUILD_PLATFORM_ID}
};

static struct xe_guc *
log_to_guc(struct xe_guc_log *log)
{
	return container_of(log, struct xe_guc, log);
}

static struct xe_gt *
log_to_gt(struct xe_guc_log *log)
{
	return container_of(log, struct xe_gt, uc.guc.log);
}

static struct xe_device *
log_to_xe(struct xe_guc_log *log)
{
	return gt_to_xe(log_to_gt(log));
}

static struct xe_guc_log_snapshot *xe_guc_log_snapshot_alloc(struct xe_guc_log *log, bool atomic)
{
	struct xe_guc_log_snapshot *snapshot;
	size_t remain;
	int i;

	snapshot = kzalloc_obj(*snapshot, atomic ? GFP_ATOMIC : GFP_KERNEL);
	if (!snapshot)
		return NULL;

	/*
	 * NB: kmalloc has a hard limit well below the maximum GuC log buffer size.
	 * Also, can't use vmalloc as might be called from atomic context. So need
	 * to break the buffer up into smaller chunks that can be allocated.
	 */
	snapshot->size = xe_bo_size(log->bo);
	snapshot->num_chunks = DIV_ROUND_UP(snapshot->size, GUC_LOG_CHUNK_SIZE);

	snapshot->copy = kzalloc_objs(*snapshot->copy, snapshot->num_chunks,
				      atomic ? GFP_ATOMIC : GFP_KERNEL);
	if (!snapshot->copy)
		goto fail_snap;

	remain = snapshot->size;
	for (i = 0; i < snapshot->num_chunks; i++) {
		size_t size = min(GUC_LOG_CHUNK_SIZE, remain);

		snapshot->copy[i] = kmalloc(size, atomic ? GFP_ATOMIC : GFP_KERNEL);
		if (!snapshot->copy[i])
			goto fail_copy;
		remain -= size;
	}

	return snapshot;

fail_copy:
	for (i = 0; i < snapshot->num_chunks; i++)
		kfree(snapshot->copy[i]);
	kfree(snapshot->copy);
fail_snap:
	kfree(snapshot);
	return NULL;
}

/**
 * xe_guc_log_snapshot_free - free a previously captured GuC log snapshot
 * @snapshot: GuC log snapshot structure
 *
 * Return: pointer to a newly allocated snapshot object or null if out of memory. Caller is
 * responsible for calling xe_guc_log_snapshot_free when done with the snapshot.
 */
void xe_guc_log_snapshot_free(struct xe_guc_log_snapshot *snapshot)
{
	int i;

	if (!snapshot)
		return;

	if (snapshot->copy) {
		for (i = 0; i < snapshot->num_chunks; i++)
			kfree(snapshot->copy[i]);
		kfree(snapshot->copy);
	}

	kfree(snapshot);
}

/**
 * xe_guc_log_snapshot_capture - create a new snapshot copy the GuC log for later dumping
 * @log: GuC log structure
 * @atomic: is the call inside an atomic section of some kind?
 *
 * Return: pointer to a newly allocated snapshot object or null if out of memory. Caller is
 * responsible for calling xe_guc_log_snapshot_free when done with the snapshot.
 */
struct xe_guc_log_snapshot *xe_guc_log_snapshot_capture(struct xe_guc_log *log, bool atomic)
{
	struct xe_guc_log_snapshot *snapshot;
	struct xe_device *xe = log_to_xe(log);
	struct xe_guc *guc = log_to_guc(log);
	struct xe_gt *gt = log_to_gt(log);
	size_t remain;
	int i;

	if (!log->bo)
		return NULL;

	snapshot = xe_guc_log_snapshot_alloc(log, atomic);
	if (!snapshot)
		return NULL;

	remain = snapshot->size;
	for (i = 0; i < snapshot->num_chunks; i++) {
		size_t size = min(GUC_LOG_CHUNK_SIZE, remain);

		xe_map_memcpy_from(xe, snapshot->copy[i], &log->bo->vmap,
				   i * GUC_LOG_CHUNK_SIZE, size);
		remain -= size;
	}

	CLASS(xe_force_wake, fw_ref)(gt_to_fw(gt), XE_FW_GT);
	if (!fw_ref.domains)
		snapshot->stamp = ~0ULL;
	else
		snapshot->stamp = xe_mmio_read64_2x32(&gt->mmio, GUC_PMTIMESTAMP_LO);

	snapshot->ktime = ktime_get_boottime_ns();
	snapshot->level = log->level;
	snapshot->ver_found = guc->fw.versions.found[XE_UC_FW_VER_RELEASE];
	snapshot->ver_want = guc->fw.versions.wanted;
	snapshot->path = guc->fw.path;

	return snapshot;
}

/**
 * xe_guc_log_snapshot_print - dump a previously saved copy of the GuC log to some useful location
 * @snapshot: a snapshot of the GuC log
 * @p: the printer object to output to
 */
void xe_guc_log_snapshot_print(struct xe_guc_log_snapshot *snapshot, struct drm_printer *p)
{
	size_t remain;
	int i;

	if (!snapshot) {
		drm_printf(p, "GuC log snapshot not allocated!\n");
		return;
	}

	drm_printf(p, "GuC firmware: %s\n", snapshot->path);
	drm_printf(p, "GuC version: %u.%u.%u (wanted %u.%u.%u)\n",
		   snapshot->ver_found.major, snapshot->ver_found.minor, snapshot->ver_found.patch,
		   snapshot->ver_want.major, snapshot->ver_want.minor, snapshot->ver_want.patch);
	drm_printf(p, "Kernel timestamp: 0x%08llX [%llu]\n", snapshot->ktime, snapshot->ktime);
	drm_printf(p, "GuC timestamp: 0x%08llX [%llu]\n", snapshot->stamp, snapshot->stamp);
	drm_printf(p, "Log level: %u\n", snapshot->level);

	drm_printf(p, "[LOG].length: 0x%zx\n", snapshot->size);
	remain = snapshot->size;
	for (i = 0; i < snapshot->num_chunks; i++) {
		size_t size = min(GUC_LOG_CHUNK_SIZE, remain);
		const char *prefix = i ? NULL : "[LOG].data";
		char suffix = i == snapshot->num_chunks - 1 ? '\n' : 0;

		xe_print_blob_ascii85(p, prefix, suffix, snapshot->copy[i], 0, size);
		remain -= size;
	}
}

static inline void lfd_output_binary(struct drm_printer *p, char *buf, int buf_size)
{
	seq_write(p->arg, buf, buf_size);
}

static inline int xe_guc_log_add_lfd_header(struct guc_lfd_data *lfd)
{
	lfd->header = FIELD_PREP_CONST(GUC_LFD_DATA_HEADER_MASK_MAGIC, GUC_LFD_DATA_HEADER_MAGIC);
	return offsetof(struct guc_lfd_data, data);
}

static int xe_guc_log_add_typed_payload(struct drm_printer *p, u32 type,
					u32 data_len, void *data)
{
	struct guc_lfd_data lfd;
	int len;

	len = xe_guc_log_add_lfd_header(&lfd);
	lfd.header |= FIELD_PREP(GUC_LFD_DATA_HEADER_MASK_TYPE, type);
	/* make length DW aligned */
	lfd.data_count = DIV_ROUND_UP(data_len, sizeof(u32));
	lfd_output_binary(p, (char *)&lfd, len);

	lfd_output_binary(p, data, data_len);
	len += lfd.data_count * sizeof(u32);

	return len;
}

static inline int lic_type_to_index(u32 lic_type)
{
	XE_WARN_ON(lic_type < GUC_LIC_TYPE_FIRST || lic_type > GUC_LIC_TYPE_LAST);

	return lic_type - GUC_LIC_TYPE_FIRST;
}

static inline int lfd_type_to_index(u32 lfd_type)
{
	int i, lic_type = 0;

	XE_WARN_ON(lfd_type < GUC_LFD_TYPE_FW_RANGE_FIRST || lfd_type > GUC_LFD_TYPE_FW_RANGE_LAST);

	for (i = 0; i < ARRAY_SIZE(lic_lfd_type_map); i++)
		if (lic_lfd_type_map[i].lfd == lfd_type)
			lic_type = lic_lfd_type_map[i].lic;

	/* If not found, lic_type_to_index will warning invalid type */
	return lic_type_to_index(lic_type);
}

static int xe_guc_log_add_klv(struct drm_printer *p, u32 lfd_type,
			      struct guc_lic_save *config)
{
	int klv_index = lfd_type_to_index(lfd_type);

	return xe_guc_log_add_typed_payload(p, lfd_type, sizeof(u32), &config->values[klv_index]);
}

static int xe_guc_log_add_os_id(struct drm_printer *p, u32 id)
{
	struct guc_lfd_data_os_info os_id;
	struct guc_lfd_data lfd;
	int len, info_len, section_len;
	char *version;
	u32 blank = 0;

	len = xe_guc_log_add_lfd_header(&lfd);
	lfd.header |= FIELD_PREP(GUC_LFD_DATA_HEADER_MASK_TYPE, GUC_LFD_TYPE_OS_ID);

	os_id.os_id = id;
	section_len = offsetof(struct guc_lfd_data_os_info, build_version);

	version = init_utsname()->release;
	info_len = strlen(version);

	/* make length DW aligned */
	lfd.data_count = DIV_ROUND_UP(section_len + info_len, sizeof(u32));
	lfd_output_binary(p, (char *)&lfd, len);
	lfd_output_binary(p, (char *)&os_id, section_len);
	lfd_output_binary(p, version, info_len);

	/* Padding with 0 */
	section_len = lfd.data_count * sizeof(u32) - section_len - info_len;
	if (section_len)
		lfd_output_binary(p, (char *)&blank, section_len);

	len +=  lfd.data_count * sizeof(u32);
	return len;
}

static void xe_guc_log_loop_log_init(struct guc_lic *init, struct guc_lic_save *config)
{
	struct guc_klv_generic_dw_t *p = (void *)init->data;
	int i;

	for (i = 0; i < init->data_count;) {
		int klv_len = FIELD_GET(GUC_KLV_0_LEN, p->kl) + 1;
		int key = FIELD_GET(GUC_KLV_0_KEY, p->kl);

		if (key < GUC_LIC_TYPE_FIRST || key > GUC_LIC_TYPE_LAST) {
			XE_WARN_ON(key < GUC_LIC_TYPE_FIRST || key > GUC_LIC_TYPE_LAST);
			break;
		}
		config->values[lic_type_to_index(key)] = p->value;
		i += klv_len + 1; /* Whole KLV structure length in dwords */
		p = (void *)((u32 *)p + klv_len);
	}
}

static int find_marker(u32 mark0, u32 mark1)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(entry_markers); i++)
		if (mark0 == entry_markers[i].key[0] && mark1 == entry_markers[i].key[1])
			return i;

	return ARRAY_SIZE(entry_markers);
}

static void xe_guc_log_load_lic(void *guc_log, struct guc_lic_save *config)
{
	u32 offset = GUC_LOG_BUFFER_STATE_HEADER_LENGTH;
	struct guc_log_buffer_state *p = guc_log;

	config->version = p->version;
	while (p->marker[0]) {
		int index;

		index = find_marker(p->marker[0], p->marker[1]);

		if (index < ARRAY_SIZE(entry_markers)) {
			if (index == GUC_LOG_BUFFER_INIT_CONFIG) {
				/* Load log init config */
				xe_guc_log_loop_log_init((void *)p, config);

				/* LIC structure is the last */
				return;
			}
			config->entry[index].offset = offset;
			config->entry[index].rd_ptr = p->read_ptr;
			config->entry[index].wr_ptr = p->write_ptr;
			config->entry[index].wrap_offset = p->wrap_offset;
			config->entry[index].buf_size = p->size;
		}
		offset += p->size;
		p++;
	}
}

static int
xe_guc_log_output_lfd_init(struct drm_printer *p, struct xe_guc_log_snapshot *snapshot,
			   struct guc_lic_save *config)
{
	int type, len;
	size_t size = 0;

	/* FW required types */
	for (type = GUC_LFD_TYPE_FW_RANGE_FIRST; type <= GUC_LFD_TYPE_FW_RANGE_LAST; type++)
		size += xe_guc_log_add_klv(p, type, config);

	/* KMD required type(s) */
	len = xe_guc_log_add_os_id(p, GUC_LFD_OS_TYPE_OSID_LIN);
	size += len;

	return size;
}

static void
xe_guc_log_print_chunks(struct drm_printer *p, struct xe_guc_log_snapshot *snapshot,
			u32 from, u32 to)
{
	int chunk_from = from % GUC_LOG_CHUNK_SIZE;
	int chunk_id = from / GUC_LOG_CHUNK_SIZE;
	int to_chunk_id = to / GUC_LOG_CHUNK_SIZE;
	int chunk_to = to % GUC_LOG_CHUNK_SIZE;
	int pos = from;

	do {
		size_t size = (to_chunk_id == chunk_id ? chunk_to : GUC_LOG_CHUNK_SIZE) -
			      chunk_from;

		lfd_output_binary(p, snapshot->copy[chunk_id] + chunk_from, size);
		pos += size;
		chunk_id++;
		chunk_from = 0;
	} while (pos < to);
}

static inline int
xe_guc_log_add_log_event(struct drm_printer *p, struct xe_guc_log_snapshot *snapshot,
			 struct guc_lic_save *config)
{
	size_t size;
	u32 data_len, section_len;
	struct guc_lfd_data lfd;
	struct guc_log_buffer_entry_list *entry;
	struct guc_lfd_data_log_events_buf events_buf;

	entry = &config->entry[GUC_LOG_TYPE_EVENT_DATA];

	/* Skip empty log */
	if (entry->rd_ptr == entry->wr_ptr)
		return 0;

	size = xe_guc_log_add_lfd_header(&lfd);
	lfd.header |= FIELD_PREP(GUC_LFD_DATA_HEADER_MASK_TYPE, GUC_LFD_TYPE_LOG_EVENTS_BUFFER);
	events_buf.log_events_format_version = config->version;

	/* Adjust to log_format_buf */
	section_len = offsetof(struct guc_lfd_data_log_events_buf, log_event);
	data_len = section_len;

	/* Calculate data length */
	data_len += entry->rd_ptr < entry->wr_ptr ? (entry->wr_ptr - entry->rd_ptr) :
		(entry->wr_ptr + entry->wrap_offset - entry->rd_ptr);
	/* make length u32 aligned */
	lfd.data_count = DIV_ROUND_UP(data_len, sizeof(u32));

	/* Output GUC_LFD_TYPE_LOG_EVENTS_BUFFER header */
	lfd_output_binary(p, (char *)&lfd, size);
	lfd_output_binary(p, (char *)&events_buf, section_len);

	/* Output data from guc log chunks directly */
	if (entry->rd_ptr < entry->wr_ptr) {
		xe_guc_log_print_chunks(p, snapshot, entry->offset + entry->rd_ptr,
					entry->offset + entry->wr_ptr);
	} else {
		/* 1st, print from rd to wrap offset */
		xe_guc_log_print_chunks(p, snapshot, entry->offset + entry->rd_ptr,
					entry->offset + entry->wrap_offset);

		/* 2nd, print from buf start to wr */
		xe_guc_log_print_chunks(p, snapshot, entry->offset, entry->offset + entry->wr_ptr);
	}
	return size;
}

static int
xe_guc_log_add_crash_dump(struct drm_printer *p, struct xe_guc_log_snapshot *snapshot,
			  struct guc_lic_save *config)
{
	struct guc_log_buffer_entry_list *entry;
	int chunk_from, chunk_id;
	int from, to, i;
	size_t size = 0;
	u32 *buf32;

	entry = &config->entry[GUC_LOG_TYPE_CRASH_DUMP];

	/* Skip zero sized crash dump */
	if (!entry->buf_size)
		return 0;

	/* Check if crash dump section are all zero */
	from = entry->offset;
	to = entry->offset + entry->buf_size;
	chunk_from = from % GUC_LOG_CHUNK_SIZE;
	chunk_id = from / GUC_LOG_CHUNK_SIZE;
	buf32 = snapshot->copy[chunk_id] + chunk_from;

	for (i = 0; i < entry->buf_size / sizeof(u32); i++)
		if (buf32[i])
			break;

	/* Buffer has non-zero data? */
	if (i < entry->buf_size / sizeof(u32)) {
		struct guc_lfd_data lfd;

		size = xe_guc_log_add_lfd_header(&lfd);
		lfd.header |= FIELD_PREP(GUC_LFD_DATA_HEADER_MASK_TYPE, GUC_LFD_TYPE_FW_CRASH_DUMP);
		/* Calculate data length */
		lfd.data_count = DIV_ROUND_UP(entry->buf_size, sizeof(u32));
		/* Output GUC_LFD_TYPE_FW_CRASH_DUMP header */
		lfd_output_binary(p, (char *)&lfd, size);

		/* rd/wr ptr is not used for crash dump */
		xe_guc_log_print_chunks(p, snapshot, from, to);
	}
	return size;
}

static void
xe_guc_log_snapshot_print_lfd(struct xe_guc_log_snapshot *snapshot, struct drm_printer *p)
{
	struct guc_lfd_file_header header;
	struct guc_lic_save config;
	size_t size;

	if (!snapshot || !snapshot->size)
		return;

	header.magic = GUC_LFD_DRIVER_KEY_STREAMING;
	header.version = FIELD_PREP_CONST(GUC_LFD_FILE_HEADER_VERSION_MASK_MINOR,
					  GUC_LFD_FORMAT_VERSION_MINOR) |
			 FIELD_PREP_CONST(GUC_LFD_FILE_HEADER_VERSION_MASK_MAJOR,
					  GUC_LFD_FORMAT_VERSION_MAJOR);

	/* Output LFD file header */
	lfd_output_binary(p, (char *)&header,
			  offsetof(struct guc_lfd_file_header, stream));

	/* Output LFD stream */
	xe_guc_log_load_lic(snapshot->copy[0], &config);
	size = xe_guc_log_output_lfd_init(p, snapshot, &config);
	if (!size)
		return;

	xe_guc_log_add_log_event(p, snapshot, &config);
	xe_guc_log_add_crash_dump(p, snapshot, &config);
}

/**
 * xe_guc_log_print_dmesg - dump a copy of the GuC log to dmesg
 * @log: GuC log structure
 */
void xe_guc_log_print_dmesg(struct xe_guc_log *log)
{
	struct xe_gt *gt = log_to_gt(log);
	static int g_count;
	struct drm_printer ip = xe_gt_info_printer(gt);
	struct drm_printer lp = drm_line_printer(&ip, "Capture", ++g_count);

	drm_printf(&lp, "Dumping GuC log for %ps...\n", __builtin_return_address(0));

	xe_guc_log_print(log, &lp);

	drm_printf(&lp, "Done.\n");
}

/**
 * xe_guc_log_print - dump a copy of the GuC log to some useful location
 * @log: GuC log structure
 * @p: the printer object to output to
 */
void xe_guc_log_print(struct xe_guc_log *log, struct drm_printer *p)
{
	struct xe_guc_log_snapshot *snapshot;

	drm_printf(p, "**** GuC Log ****\n");

	snapshot = xe_guc_log_snapshot_capture(log, false);
	drm_printf(p, "CS reference clock: %u\n", log_to_gt(log)->info.reference_clock);
	xe_guc_log_snapshot_print(snapshot, p);
	xe_guc_log_snapshot_free(snapshot);
}

/**
 * xe_guc_log_print_lfd - dump a copy of the GuC log in LFD format
 * @log: GuC log structure
 * @p: the printer object to output to
 */
void xe_guc_log_print_lfd(struct xe_guc_log *log, struct drm_printer *p)
{
	struct xe_guc_log_snapshot *snapshot;

	snapshot = xe_guc_log_snapshot_capture(log, false);
	xe_guc_log_snapshot_print_lfd(snapshot, p);
	xe_guc_log_snapshot_free(snapshot);
}

int xe_guc_log_init(struct xe_guc_log *log)
{
	struct xe_device *xe = log_to_xe(log);
	struct xe_tile *tile = gt_to_tile(log_to_gt(log));
	struct xe_bo *bo;

	bo = xe_managed_bo_create_pin_map(xe, tile, GUC_LOG_SIZE,
					  XE_BO_FLAG_SYSTEM |
					  XE_BO_FLAG_GGTT |
					  XE_BO_FLAG_GGTT_INVALIDATE |
					  XE_BO_FLAG_PINNED_NORESTORE);
	if (IS_ERR(bo))
		return PTR_ERR(bo);

	xe_map_memset(xe, &bo->vmap, 0, 0, xe_bo_size(bo));
	log->bo = bo;
	log->level = xe_modparam.guc_log_level;

	return 0;
}

ALLOW_ERROR_INJECTION(xe_guc_log_init, ERRNO); /* See xe_pci_probe() */

/**
 * xe_guc_check_log_buf_overflow - Check if log buffer overflowed
 * @log: The log object.
 * @type: The log buffer type
 * @full_cnt: The count of buffer full
 *
 * This function will check count of buffer full against previous, mismatch
 * indicate overflowed.
 * Update the sampled_overflow counter, if the 4 bit counter overflowed, add
 * up 16 to correct the value.
 *
 * Return: True if overflowed.
 */
bool xe_guc_check_log_buf_overflow(struct xe_guc_log *log, enum guc_log_type type,
				   unsigned int full_cnt)
{
	unsigned int prev_full_cnt = log->stats[type].sampled_overflow;
	bool overflow = false;

	if (full_cnt != prev_full_cnt) {
		overflow = true;

		log->stats[type].overflow = full_cnt;
		log->stats[type].sampled_overflow += full_cnt - prev_full_cnt;

		if (full_cnt < prev_full_cnt) {
			/* buffer_full_cnt is a 4 bit counter */
			log->stats[type].sampled_overflow += 16;
		}
		xe_gt_notice(log_to_gt(log), "log buffer overflow\n");
	}

	return overflow;
}