#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
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
#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
#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
{
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
* 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:
{
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));
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
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. */
#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
#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)
{
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;
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 |
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;
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.
*
* 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;
struct xe_device;
#if IS_ENABLED(CONFIG_DRM_XE_DEBUG_GUC)
-#define CRASH_BUFFER_SIZE SZ_1M
-#define DEBUG_BUFFER_SIZE SZ_8M
-#define CAPTURE_BUFFER_SIZE SZ_2M
+#define XE_GUC_LOG_EVENT_DATA_BUFFER_SIZE SZ_8M
+#define XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE SZ_1M
+#define XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE SZ_2M
#else
-#define CRASH_BUFFER_SIZE SZ_16K
-#define DEBUG_BUFFER_SIZE SZ_64K
-#define CAPTURE_BUFFER_SIZE SZ_1M
+#define XE_GUC_LOG_EVENT_DATA_BUFFER_SIZE SZ_64K
+#define XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE SZ_16K
+#define XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE SZ_1M
#endif
+
+#define GUC_LOG_SIZE (SZ_4K + \
+ XE_GUC_LOG_EVENT_DATA_BUFFER_SIZE + \
+ XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE + \
+ XE_GUC_LOG_STATE_CAPTURE_BUFFER_SIZE)
+
+#define XE_GUC_LOG_EVENT_DATA_OFFSET SZ_4K
+#define XE_GUC_LOG_CRASH_DUMP_OFFSET (XE_GUC_LOG_EVENT_DATA_OFFSET + \
+ XE_GUC_LOG_EVENT_DATA_BUFFER_SIZE)
+#define XE_GUC_LOG_STATE_CAPTURE_OFFSET (XE_GUC_LOG_CRASH_DUMP_OFFSET + \
+ XE_GUC_LOG_CRASH_DUMP_BUFFER_SIZE)
+
/*
* While we're using plain log level in i915, GuC controls are much more...
* "elaborate"? We have a couple of bits for verbosity, separate bit for actual
return log->level;
}
-u32 xe_guc_log_section_size_capture(struct xe_guc_log *log);
-u32 xe_guc_get_log_buffer_size(struct xe_guc_log *log, enum guc_log_buffer_type type);
-u32 xe_guc_get_log_buffer_offset(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_buffer_type type,
+ enum guc_log_type type,
unsigned int full_cnt);
#endif
projects / thirdparty / linux.git / commitdiff
