linux/drivers/gpu/drm/xe/xe_hw_engine.c

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

#include "xe_hw_engine.h"

#include <drm/drm_managed.h>

#include "regs/xe_engine_regs.h"
#include "regs/xe_gt_regs.h"
#include "xe_assert.h"
#include "xe_bo.h"
#include "xe_device.h"
#include "xe_execlist.h"
#include "xe_force_wake.h"
#include "xe_gsc.h"
#include "xe_gt.h"
#include "xe_gt_ccs_mode.h"
#include "xe_gt_printk.h"
#include "xe_gt_mcr.h"
#include "xe_gt_topology.h"
#include "xe_hw_fence.h"
#include "xe_irq.h"
#include "xe_lrc.h"
#include "xe_macros.h"
#include "xe_mmio.h"
#include "xe_reg_sr.h"
#include "xe_reg_whitelist.h"
#include "xe_rtp.h"
#include "xe_sched_job.h"
#include "xe_sriov.h"
#include "xe_tuning.h"
#include "xe_uc_fw.h"
#include "xe_wa.h"

#define MAX_MMIO_BASES …
struct engine_info { … };

static const struct engine_info engine_infos[] = …;

static void hw_engine_fini(struct drm_device *drm, void *arg)
{ … }

static void hw_engine_mmio_write32(struct xe_hw_engine *hwe, struct xe_reg reg,
				   u32 val)
{ … }

static u32 hw_engine_mmio_read32(struct xe_hw_engine *hwe, struct xe_reg reg)
{ … }

void xe_hw_engine_enable_ring(struct xe_hw_engine *hwe)
{ … }

static bool xe_hw_engine_match_fixed_cslice_mode(const struct xe_gt *gt,
						 const struct xe_hw_engine *hwe)
{ … }

static bool xe_rtp_cfeg_wmtp_disabled(const struct xe_gt *gt,
				      const struct xe_hw_engine *hwe)
{ … }

void
xe_hw_engine_setup_default_lrc_state(struct xe_hw_engine *hwe)
{ … }

static void
hw_engine_setup_default_state(struct xe_hw_engine *hwe)
{ … }

static void hw_engine_init_early(struct xe_gt *gt, struct xe_hw_engine *hwe,
				 enum xe_hw_engine_id id)
{ … }

static int hw_engine_init(struct xe_gt *gt, struct xe_hw_engine *hwe,
			  enum xe_hw_engine_id id)
{ … }

static void hw_engine_setup_logical_mapping(struct xe_gt *gt)
{ … }

static void read_media_fuses(struct xe_gt *gt)
{ … }

static void read_copy_fuses(struct xe_gt *gt)
{ … }

static void read_compute_fuses_from_dss(struct xe_gt *gt)
{ … }

static void read_compute_fuses_from_reg(struct xe_gt *gt)
{ … }

static void read_compute_fuses(struct xe_gt *gt)
{ … }

static void check_gsc_availability(struct xe_gt *gt)
{ … }

int xe_hw_engines_init_early(struct xe_gt *gt)
{ … }

int xe_hw_engines_init(struct xe_gt *gt)
{ … }

void xe_hw_engine_handle_irq(struct xe_hw_engine *hwe, u16 intr_vec)
{ … }

static bool
is_slice_common_per_gslice(struct xe_device *xe)
{ … }

static void
xe_hw_engine_snapshot_instdone_capture(struct xe_hw_engine *hwe,
				       struct xe_hw_engine_snapshot *snapshot)
{ … }

/**
 * xe_hw_engine_snapshot_capture - Take a quick snapshot of the HW Engine.
 * @hwe: Xe HW Engine.
 *
 * This can be printed out in a later stage like during dev_coredump
 * analysis.
 *
 * Returns: a Xe HW Engine snapshot object that must be freed by the
 * caller, using `xe_hw_engine_snapshot_free`.
 */
struct xe_hw_engine_snapshot *
xe_hw_engine_snapshot_capture(struct xe_hw_engine *hwe)
{ … }

static void
xe_hw_engine_snapshot_instdone_print(struct xe_hw_engine_snapshot *snapshot, struct drm_printer *p)
{ … }

/**
 * xe_hw_engine_snapshot_print - Print out a given Xe HW Engine snapshot.
 * @snapshot: Xe HW Engine snapshot object.
 * @p: drm_printer where it will be printed out.
 *
 * This function prints out a given Xe HW Engine snapshot object.
 */
void xe_hw_engine_snapshot_print(struct xe_hw_engine_snapshot *snapshot,
				 struct drm_printer *p)
{ … }

/**
 * xe_hw_engine_snapshot_free - Free all allocated objects for a given snapshot.
 * @snapshot: Xe HW Engine snapshot object.
 *
 * This function free all the memory that needed to be allocated at capture
 * time.
 */
void xe_hw_engine_snapshot_free(struct xe_hw_engine_snapshot *snapshot)
{ … }

/**
 * xe_hw_engine_print - Xe HW Engine Print.
 * @hwe: Hardware Engine.
 * @p: drm_printer.
 *
 * This function quickly capture a snapshot and immediately print it out.
 */
void xe_hw_engine_print(struct xe_hw_engine *hwe, struct drm_printer *p)
{ … }

u32 xe_hw_engine_mask_per_class(struct xe_gt *gt,
				enum xe_engine_class engine_class)
{ … }

bool xe_hw_engine_is_reserved(struct xe_hw_engine *hwe)
{ … }

const char *xe_hw_engine_class_to_str(enum xe_engine_class class)
{ … }

u64 xe_hw_engine_read_timestamp(struct xe_hw_engine *hwe)
{ … }

enum xe_force_wake_domains xe_hw_engine_to_fw_domain(struct xe_hw_engine *hwe)
{ … }