Commit f4c8298c authored by Zhanjun Dong's avatar Zhanjun Dong Committed by Daniele Ceraolo Spurio
Browse files

drm/xe/guc: Cleanup GuC log buffer macros and helpers 



Cleanup GuC log buffer macros and helpers, add Xe style macro prefix.
Update buffer type values to align with the GuC specification
Update buffer offset calculation.
Remove helper functions, replaced with macros.

Signed-off-by: default avatarZhanjun Dong <zhanjun.dong@intel.com>
Reviewed-by: default avatarMichal Wajdeczko <michal.wajdeczko@intel.com>
Signed-off-by: default avatarDaniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Link: https://patch.msgid.link/20251105233143.1168759-1-zhanjun.dong@intel.com
parent 5a062505

drivers/gpu/drm/xe/abi/guc_log_abi.h

+38 −4
Original line number Diff line number Diff line
@@ -8,11 +8,45 @@ 


#include <linux/types.h>



/**

 * DOC: GuC Log buffer Layout

 *

 * The in-memory log buffer layout is as follows::

 *

 *  +===============================+	      0000h

 *  |    Crash dump state header    |		^

 *  +-------------------------------+ 32B	|

 *  |      Debug state header       |		|

 *  +-------------------------------+ 64B	4KB

 *  |     Capture state header      |		|

 *  +-------------------------------+ 96B	|

 *  |                               |		v

 *  +===============================+ <--- EVENT_DATA_OFFSET

 *  |  Event logs(raw data)         |		^

 *  |                               |		|

 *  |                               | EVENT_DATA_BUFFER_SIZE

 *  |                               |		|

 *  |                               |		v

 *  +===============================+ <--- CRASH_DUMP_OFFSET

 *  | Crash Dump(raw data)          |		^

 *  |                               |		|

 *  |                               | CRASH_DUMP_BUFFER_SIZE

 *  |                               |		|

 *  |                               |		v

 *  +===============================+ <--- STATE_CAPTURE_OFFSET

 *  | Error state capture(raw data) |		^

 *  |                               |		|

 *  |                               | STATE_CAPTURE_BUFFER_SIZE

 *  |                               |		|

 *  |                               |		v

 *  +===============================+ Total: GUC_LOG_SIZE

 */



/* GuC logging buffer types */

enum guc_log_buffer_type {

	GUC_LOG_BUFFER_CRASH_DUMP,

	GUC_LOG_BUFFER_DEBUG,

	GUC_LOG_BUFFER_CAPTURE,

enum guc_log_type {

	GUC_LOG_TYPE_EVENT_DATA,

	GUC_LOG_TYPE_CRASH_DUMP,

	GUC_LOG_TYPE_STATE_CAPTURE,

};



#define GUC_LOG_BUFFER_TYPE_MAX		3

drivers/gpu/drm/xe/xe_guc.c

+12 −11
Original line number Diff line number Diff line
@@ -104,7 +104,7 @@ static u32 guc_ctl_log_params_flags(struct xe_guc *guc) 
	u32 offset = guc_bo_ggtt_addr(guc, guc->log.bo) >> PAGE_SHIFT;

	u32 flags;



	#if (((CRASH_BUFFER_SIZE) % SZ_1M) == 0)

	#if (((XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE) % SZ_1M) == 0)

	#define LOG_UNIT SZ_1M

	#define LOG_FLAG GUC_LOG_LOG_ALLOC_UNITS

	#else
@@ -112,7 +112,7 @@ static u32 guc_ctl_log_params_flags(struct xe_guc *guc) 
	#define LOG_FLAG 0

	#endif



	#if (((CAPTURE_BUFFER_SIZE) % SZ_1M) == 0)

	#if (((XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE) % SZ_1M) == 0)

	#define CAPTURE_UNIT SZ_1M

	#define CAPTURE_FLAG GUC_LOG_CAPTURE_ALLOC_UNITS

	#else
@@ -120,20 +120,21 @@ static u32 guc_ctl_log_params_flags(struct xe_guc *guc) 
	#define CAPTURE_FLAG 0

	#endif



	BUILD_BUG_ON(!CRASH_BUFFER_SIZE);

	BUILD_BUG_ON(!IS_ALIGNED(CRASH_BUFFER_SIZE, LOG_UNIT));

	BUILD_BUG_ON(!DEBUG_BUFFER_SIZE);

	BUILD_BUG_ON(!IS_ALIGNED(DEBUG_BUFFER_SIZE, LOG_UNIT));

	BUILD_BUG_ON(!CAPTURE_BUFFER_SIZE);

	BUILD_BUG_ON(!IS_ALIGNED(CAPTURE_BUFFER_SIZE, CAPTURE_UNIT));

	BUILD_BUG_ON(!XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE);

	BUILD_BUG_ON(!IS_ALIGNED(XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE, LOG_UNIT));

	BUILD_BUG_ON(!XE_GUC_LOG_EVENT_DATA_BUFFER_SIZE);

	BUILD_BUG_ON(!IS_ALIGNED(XE_GUC_LOG_EVENT_DATA_BUFFER_SIZE, LOG_UNIT));

	BUILD_BUG_ON(!XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE);

	BUILD_BUG_ON(!IS_ALIGNED(XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE, CAPTURE_UNIT));



	flags = GUC_LOG_VALID |

		GUC_LOG_NOTIFY_ON_HALF_FULL |

		CAPTURE_FLAG |

		LOG_FLAG |

		FIELD_PREP(GUC_LOG_CRASH, CRASH_BUFFER_SIZE / LOG_UNIT - 1) |

		FIELD_PREP(GUC_LOG_DEBUG, DEBUG_BUFFER_SIZE / LOG_UNIT - 1) |

		FIELD_PREP(GUC_LOG_CAPTURE, CAPTURE_BUFFER_SIZE / CAPTURE_UNIT - 1) |

		FIELD_PREP(GUC_LOG_CRASH_DUMP, XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE / LOG_UNIT - 1) |

		FIELD_PREP(GUC_LOG_EVENT_DATA, XE_GUC_LOG_EVENT_DATA_BUFFER_SIZE / LOG_UNIT - 1) |

		FIELD_PREP(GUC_LOG_STATE_CAPTURE, XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE /

			   CAPTURE_UNIT - 1) |

		FIELD_PREP(GUC_LOG_BUF_ADDR, offset);



	#undef LOG_UNIT

drivers/gpu/drm/xe/xe_guc_capture.c

+8 −8
Original line number Diff line number Diff line
@@ -843,7 +843,7 @@ static void check_guc_capture_size(struct xe_guc *guc) 
{

	int capture_size = guc_capture_output_size_est(guc);

	int spare_size = capture_size * GUC_CAPTURE_OVERBUFFER_MULTIPLIER;

	u32 buffer_size = xe_guc_log_section_size_capture(&guc->log);

	u32 buffer_size = XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE;



	/*

	 * NOTE: capture_size is much smaller than the capture region
@@ -949,7 +949,7 @@ guc_capture_init_node(struct xe_guc *guc, struct __guc_capture_parsed_output *no 
 *                  ADS module also calls separately for PF vs VF.

 *

 *     --> alloc B: GuC output capture buf (registered via guc_init_params(log_param))

 *                  Size = #define CAPTURE_BUFFER_SIZE (warns if on too-small)

 *                  Size = XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE (warns if on too-small)

 *                  Note2: 'x 3' to hold multiple capture groups

 *

 * GUC Runtime notify capture:
@@ -1367,7 +1367,7 @@ static int __guc_capture_flushlog_complete(struct xe_guc *guc) 
{

	u32 action[] = {

		XE_GUC_ACTION_LOG_BUFFER_FILE_FLUSH_COMPLETE,

		GUC_LOG_BUFFER_CAPTURE

		GUC_LOG_TYPE_STATE_CAPTURE

	};



	return xe_guc_ct_send_g2h_handler(&guc->ct, action, ARRAY_SIZE(action));
@@ -1384,8 +1384,8 @@ static void __guc_capture_process_output(struct xe_guc *guc) 
	u32 log_buf_state_offset;

	u32 src_data_offset;



	log_buf_state_offset = sizeof(struct guc_log_buffer_state) * GUC_LOG_BUFFER_CAPTURE;

	src_data_offset = xe_guc_get_log_buffer_offset(&guc->log, GUC_LOG_BUFFER_CAPTURE);

	log_buf_state_offset = sizeof(struct guc_log_buffer_state) * GUC_LOG_TYPE_STATE_CAPTURE;

	src_data_offset = XE_GUC_LOG_STATE_CAPTURE_OFFSET;



	/*

	 * Make a copy of the state structure, inside GuC log buffer
@@ -1395,15 +1395,15 @@ static void __guc_capture_process_output(struct xe_guc *guc) 
	xe_map_memcpy_from(guc_to_xe(guc), &log_buf_state_local, &guc->log.bo->vmap,

			   log_buf_state_offset, sizeof(struct guc_log_buffer_state));



	buffer_size = xe_guc_get_log_buffer_size(&guc->log, GUC_LOG_BUFFER_CAPTURE);

	buffer_size = XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE;

	read_offset = log_buf_state_local.read_ptr;

	write_offset = log_buf_state_local.sampled_write_ptr;

	full_count = FIELD_GET(GUC_LOG_BUFFER_STATE_BUFFER_FULL_CNT, log_buf_state_local.flags);



	/* Bookkeeping stuff */

	tmp = FIELD_GET(GUC_LOG_BUFFER_STATE_FLUSH_TO_FILE, log_buf_state_local.flags);

	guc->log.stats[GUC_LOG_BUFFER_CAPTURE].flush += tmp;

	new_overflow = xe_guc_check_log_buf_overflow(&guc->log, GUC_LOG_BUFFER_CAPTURE,

	guc->log.stats[GUC_LOG_TYPE_STATE_CAPTURE].flush += tmp;

	new_overflow = xe_guc_check_log_buf_overflow(&guc->log, GUC_LOG_TYPE_STATE_CAPTURE,

						     full_count);



	/* Now copy the actual logs. */

drivers/gpu/drm/xe/xe_guc_fwif.h

+3 −3
Original line number Diff line number Diff line
@@ -91,9 +91,9 @@ struct guc_update_exec_queue_policy { 
#define   GUC_LOG_NOTIFY_ON_HALF_FULL	BIT(1)

#define   GUC_LOG_CAPTURE_ALLOC_UNITS	BIT(2)

#define   GUC_LOG_LOG_ALLOC_UNITS	BIT(3)

#define   GUC_LOG_CRASH			REG_GENMASK(5, 4)

#define   GUC_LOG_DEBUG			REG_GENMASK(9, 6)

#define   GUC_LOG_CAPTURE		REG_GENMASK(11, 10)

#define   GUC_LOG_CRASH_DUMP		REG_GENMASK(5, 4)

#define   GUC_LOG_EVENT_DATA		REG_GENMASK(9, 6)

#define   GUC_LOG_STATE_CAPTURE		REG_GENMASK(11, 10)

#define   GUC_LOG_BUF_ADDR		REG_GENMASK(31, 12)



#define GUC_CTL_WA			1

drivers/gpu/drm/xe/xe_guc_log.c

+5 −95
Original line number Diff line number Diff line
@@ -19,6 +19,8 @@ 
#include "xe_mmio.h"

#include "xe_module.h"



#define GUC_LOG_CHUNK_SIZE	SZ_2M



static struct xe_guc *

log_to_guc(struct xe_guc_log *log)

{
@@ -37,33 +39,6 @@ log_to_xe(struct xe_guc_log *log) 
	return gt_to_xe(log_to_gt(log));

}



static size_t guc_log_size(void)

{

	/*

	 *  GuC Log buffer Layout

	 *

	 *  +===============================+ 00B

	 *  |    Crash dump state header    |

	 *  +-------------------------------+ 32B

	 *  |      Debug state header       |

	 *  +-------------------------------+ 64B

	 *  |     Capture state header      |

	 *  +-------------------------------+ 96B

	 *  |                               |

	 *  +===============================+ PAGE_SIZE (4KB)

	 *  |        Crash Dump logs        |

	 *  +===============================+ + CRASH_SIZE

	 *  |          Debug logs           |

	 *  +===============================+ + DEBUG_SIZE

	 *  |         Capture logs          |

	 *  +===============================+ + CAPTURE_SIZE

	 */

	return PAGE_SIZE + CRASH_BUFFER_SIZE + DEBUG_BUFFER_SIZE +

		CAPTURE_BUFFER_SIZE;

}



#define GUC_LOG_CHUNK_SIZE	SZ_2M



static struct xe_guc_log_snapshot *xe_guc_log_snapshot_alloc(struct xe_guc_log *log, bool atomic)

{

	struct xe_guc_log_snapshot *snapshot;
@@ -255,7 +230,7 @@ int xe_guc_log_init(struct xe_guc_log *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(),

	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 |
@@ -263,7 +238,7 @@ int xe_guc_log_init(struct xe_guc_log *log) 
	if (IS_ERR(bo))

		return PTR_ERR(bo);



	xe_map_memset(xe, &bo->vmap, 0, 0, guc_log_size());

	xe_map_memset(xe, &bo->vmap, 0, 0, xe_bo_size(bo));

	log->bo = bo;

	log->level = xe_modparam.guc_log_level;
@@ -272,71 +247,6 @@ int xe_guc_log_init(struct xe_guc_log *log) 


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



static u32 xe_guc_log_section_size_crash(struct xe_guc_log *log)

{

	return CRASH_BUFFER_SIZE;

}



static u32 xe_guc_log_section_size_debug(struct xe_guc_log *log)

{

	return DEBUG_BUFFER_SIZE;

}



/**

 * xe_guc_log_section_size_capture - Get capture buffer size within log sections.

 * @log: The log object.

 *

 * This function will return the capture buffer size within log sections.

 *

 * Return: capture buffer size.

 */

u32 xe_guc_log_section_size_capture(struct xe_guc_log *log)

{

	return CAPTURE_BUFFER_SIZE;

}



/**

 * xe_guc_get_log_buffer_size - Get log buffer size for a type.

 * @log: The log object.

 * @type: The log buffer type

 *

 * Return: buffer size.

 */

u32 xe_guc_get_log_buffer_size(struct xe_guc_log *log, enum guc_log_buffer_type type)

{

	switch (type) {

	case GUC_LOG_BUFFER_CRASH_DUMP:

		return xe_guc_log_section_size_crash(log);

	case GUC_LOG_BUFFER_DEBUG:

		return xe_guc_log_section_size_debug(log);

	case GUC_LOG_BUFFER_CAPTURE:

		return xe_guc_log_section_size_capture(log);

	}

	return 0;

}



/**

 * xe_guc_get_log_buffer_offset - Get offset in log buffer for a type.

 * @log: The log object.

 * @type: The log buffer type

 *

 * This function will return the offset in the log buffer for a type.

 * Return: buffer offset.

 */

u32 xe_guc_get_log_buffer_offset(struct xe_guc_log *log, enum guc_log_buffer_type type)

{

	enum guc_log_buffer_type i;

	u32 offset = PAGE_SIZE;/* for the log_buffer_states */



	for (i = GUC_LOG_BUFFER_CRASH_DUMP; i < GUC_LOG_BUFFER_TYPE_MAX; ++i) {

		if (i == type)

			break;

		offset += xe_guc_get_log_buffer_size(log, i);

	}



	return offset;

}



/**

 * xe_guc_check_log_buf_overflow - Check if log buffer overflowed

 * @log: The log object.
@@ -350,7 +260,7 @@ u32 xe_guc_get_log_buffer_offset(struct xe_guc_log *log, enum guc_log_buffer_typ 
 *

 * Return: True if overflowed.

 */

bool xe_guc_check_log_buf_overflow(struct xe_guc_log *log, enum guc_log_buffer_type type,

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;