// SPDX-License-Identifier: MIT /* * Copyright © 2022 Intel Corporation */ #include "xe_guc_pc.h" #include <linux/delay.h> #include <drm/drm_managed.h> #include <generated/xe_wa_oob.h> #include "abi/guc_actions_slpc_abi.h" #include "regs/xe_gt_regs.h" #include "regs/xe_regs.h" #include "xe_bo.h" #include "xe_device.h" #include "xe_force_wake.h" #include "xe_gt.h" #include "xe_gt_idle.h" #include "xe_gt_printk.h" #include "xe_gt_types.h" #include "xe_guc.h" #include "xe_guc_ct.h" #include "xe_map.h" #include "xe_mmio.h" #include "xe_pcode.h" #include "xe_pm.h" #include "xe_sriov.h" #include "xe_wa.h" #define MCHBAR_MIRROR_BASE_SNB … #define RP_STATE_CAP … #define RP0_MASK … #define RP1_MASK … #define RPN_MASK … #define FREQ_INFO_REC … #define RPE_MASK … #define GT_PERF_STATUS … #define CAGF_MASK … #define GT_FREQUENCY_MULTIPLIER … #define GT_FREQUENCY_SCALER … #define LNL_MERT_FREQ_CAP … #define BMG_MERT_FREQ_CAP … /** * DOC: GuC Power Conservation (PC) * * GuC Power Conservation (PC) supports multiple features for the most * efficient and performing use of the GT when GuC submission is enabled, * including frequency management, Render-C states management, and various * algorithms for power balancing. * * Single Loop Power Conservation (SLPC) is the name given to the suite of * connected power conservation features in the GuC firmware. The firmware * exposes a programming interface to the host for the control of SLPC. * * Frequency management: * ===================== * * Xe driver enables SLPC with all of its defaults features and frequency * selection, which varies per platform. * * Render-C States: * ================ * * Render-C states is also a GuC PC feature that is now enabled in Xe for * all platforms. * */ static struct xe_guc *pc_to_guc(struct xe_guc_pc *pc) { … } static struct xe_guc_ct *pc_to_ct(struct xe_guc_pc *pc) { … } static struct xe_gt *pc_to_gt(struct xe_guc_pc *pc) { … } static struct xe_device *pc_to_xe(struct xe_guc_pc *pc) { … } static struct iosys_map *pc_to_maps(struct xe_guc_pc *pc) { … } #define slpc_shared_data_read(pc_, field_) … #define slpc_shared_data_write(pc_, field_, val_) … #define SLPC_EVENT(id, count) … static int wait_for_pc_state(struct xe_guc_pc *pc, enum slpc_global_state state) { … } static int pc_action_reset(struct xe_guc_pc *pc) { … } static int pc_action_query_task_state(struct xe_guc_pc *pc) { … } static int pc_action_set_param(struct xe_guc_pc *pc, u8 id, u32 value) { … } static int pc_action_unset_param(struct xe_guc_pc *pc, u8 id) { … } static int pc_action_setup_gucrc(struct xe_guc_pc *pc, u32 mode) { … } static u32 decode_freq(u32 raw) { … } static u32 encode_freq(u32 freq) { … } static u32 pc_get_min_freq(struct xe_guc_pc *pc) { … } static void pc_set_manual_rp_ctrl(struct xe_guc_pc *pc, bool enable) { … } static void pc_set_cur_freq(struct xe_guc_pc *pc, u32 freq) { … } static int pc_set_min_freq(struct xe_guc_pc *pc, u32 freq) { … } static int pc_get_max_freq(struct xe_guc_pc *pc) { … } static int pc_set_max_freq(struct xe_guc_pc *pc, u32 freq) { … } static void mtl_update_rpe_value(struct xe_guc_pc *pc) { … } static void tgl_update_rpe_value(struct xe_guc_pc *pc) { … } static void pc_update_rp_values(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_get_act_freq - Get Actual running frequency * @pc: The GuC PC * * Returns: The Actual running frequency. Which might be 0 if GT is in Render-C sleep state (RC6). */ u32 xe_guc_pc_get_act_freq(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_get_cur_freq - Get Current requested frequency * @pc: The GuC PC * @freq: A pointer to a u32 where the freq value will be returned * * Returns: 0 on success, * -EAGAIN if GuC PC not ready (likely in middle of a reset). */ int xe_guc_pc_get_cur_freq(struct xe_guc_pc *pc, u32 *freq) { … } /** * xe_guc_pc_get_rp0_freq - Get the RP0 freq * @pc: The GuC PC * * Returns: RP0 freq. */ u32 xe_guc_pc_get_rp0_freq(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_get_rpe_freq - Get the RPe freq * @pc: The GuC PC * * Returns: RPe freq. */ u32 xe_guc_pc_get_rpe_freq(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_get_rpn_freq - Get the RPn freq * @pc: The GuC PC * * Returns: RPn freq. */ u32 xe_guc_pc_get_rpn_freq(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_get_min_freq - Get the min operational frequency * @pc: The GuC PC * @freq: A pointer to a u32 where the freq value will be returned * * Returns: 0 on success, * -EAGAIN if GuC PC not ready (likely in middle of a reset). */ int xe_guc_pc_get_min_freq(struct xe_guc_pc *pc, u32 *freq) { … } /** * xe_guc_pc_set_min_freq - Set the minimal operational frequency * @pc: The GuC PC * @freq: The selected minimal frequency * * Returns: 0 on success, * -EAGAIN if GuC PC not ready (likely in middle of a reset), * -EINVAL if value out of bounds. */ int xe_guc_pc_set_min_freq(struct xe_guc_pc *pc, u32 freq) { … } /** * xe_guc_pc_get_max_freq - Get Maximum operational frequency * @pc: The GuC PC * @freq: A pointer to a u32 where the freq value will be returned * * Returns: 0 on success, * -EAGAIN if GuC PC not ready (likely in middle of a reset). */ int xe_guc_pc_get_max_freq(struct xe_guc_pc *pc, u32 *freq) { … } /** * xe_guc_pc_set_max_freq - Set the maximum operational frequency * @pc: The GuC PC * @freq: The selected maximum frequency value * * Returns: 0 on success, * -EAGAIN if GuC PC not ready (likely in middle of a reset), * -EINVAL if value out of bounds. */ int xe_guc_pc_set_max_freq(struct xe_guc_pc *pc, u32 freq) { … } /** * xe_guc_pc_c_status - get the current GT C state * @pc: XE_GuC_PC instance */ enum xe_gt_idle_state xe_guc_pc_c_status(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_rc6_residency - rc6 residency counter * @pc: Xe_GuC_PC instance */ u64 xe_guc_pc_rc6_residency(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_mc6_residency - mc6 residency counter * @pc: Xe_GuC_PC instance */ u64 xe_guc_pc_mc6_residency(struct xe_guc_pc *pc) { … } static void mtl_init_fused_rp_values(struct xe_guc_pc *pc) { … } static void tgl_init_fused_rp_values(struct xe_guc_pc *pc) { … } static void pc_init_fused_rp_values(struct xe_guc_pc *pc) { … } static u32 pc_max_freq_cap(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_raise_unslice - Initialize RPx values and request a higher GT * frequency to allow faster GuC load times * @pc: Xe_GuC_PC instance */ void xe_guc_pc_raise_unslice(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_init_early - Initialize RPx values * @pc: Xe_GuC_PC instance */ void xe_guc_pc_init_early(struct xe_guc_pc *pc) { … } static int pc_adjust_freq_bounds(struct xe_guc_pc *pc) { … } static int pc_adjust_requested_freq(struct xe_guc_pc *pc) { … } static int pc_set_mert_freq_cap(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_restore_stashed_freq - Set min/max back to stashed values * @pc: The GuC PC * * Returns: 0 on success, * error code on failure */ int xe_guc_pc_restore_stashed_freq(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_gucrc_disable - Disable GuC RC * @pc: Xe_GuC_PC instance * * Disables GuC RC by taking control of RC6 back from GuC. * * Return: 0 on success, negative error code on error. */ int xe_guc_pc_gucrc_disable(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_override_gucrc_mode - override GUCRC mode * @pc: Xe_GuC_PC instance * @mode: new value of the mode. * * Return: 0 on success, negative error code on error */ int xe_guc_pc_override_gucrc_mode(struct xe_guc_pc *pc, enum slpc_gucrc_mode mode) { … } /** * xe_guc_pc_unset_gucrc_mode - unset GUCRC mode override * @pc: Xe_GuC_PC instance * * Return: 0 on success, negative error code on error */ int xe_guc_pc_unset_gucrc_mode(struct xe_guc_pc *pc) { … } static void pc_init_pcode_freq(struct xe_guc_pc *pc) { … } static int pc_init_freqs(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_start - Start GuC's Power Conservation component * @pc: Xe_GuC_PC instance */ int xe_guc_pc_start(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_stop - Stop GuC's Power Conservation component * @pc: Xe_GuC_PC instance */ int xe_guc_pc_stop(struct xe_guc_pc *pc) { … } /** * xe_guc_pc_fini_hw - Finalize GuC's Power Conservation component * @arg: opaque pointer that should point to Xe_GuC_PC instance */ static void xe_guc_pc_fini_hw(void *arg) { … } /** * xe_guc_pc_init - Initialize GuC's Power Conservation component * @pc: Xe_GuC_PC instance */ int xe_guc_pc_init(struct xe_guc_pc *pc) { … }
Codebase Browser
linux