/* * Copyright 2023 Advanced Micro Devices, Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. * * Authors: AMD * */ /* FILE POLICY AND INTENDED USAGE: * This file owns the programming sequence of stream's dpms state associated * with the link and link's enable/disable sequences as result of the stream's * dpms state change. * * TODO - The reason link owns stream's dpms programming sequence is * because dpms programming sequence is highly dependent on underlying signal * specific link protocols. This unfortunately causes link to own a portion of * stream state programming sequence. This creates a gray area where the * boundary between link and stream is not clearly defined. */ #include "link_dpms.h" #include "link_hwss.h" #include "link_validation.h" #include "accessories/link_dp_trace.h" #include "protocols/link_dpcd.h" #include "protocols/link_ddc.h" #include "protocols/link_hpd.h" #include "protocols/link_dp_phy.h" #include "protocols/link_dp_capability.h" #include "protocols/link_dp_training.h" #include "protocols/link_edp_panel_control.h" #include "protocols/link_dp_dpia_bw.h" #include "dm_helpers.h" #include "link_enc_cfg.h" #include "resource.h" #include "dsc.h" #include "dccg.h" #include "clk_mgr.h" #include "atomfirmware.h" #include "vpg.h" #define DC_LOGGER … #define DC_LOGGER_INIT(logger) … #define LINK_INFO(...) … #define RETIMER_REDRIVER_INFO(...) … #define MAX_MTP_SLOT_COUNT … #define LINK_TRAINING_ATTEMPTS … #define PEAK_FACTOR_X1000 … void link_blank_all_dp_displays(struct dc *dc) { … } void link_blank_all_edp_displays(struct dc *dc) { … } void link_blank_dp_stream(struct dc_link *link, bool hw_init) { … } void link_set_all_streams_dpms_off_for_link(struct dc_link *link) { … } void link_resume(struct dc_link *link) { … } /* This function returns true if the pipe is used to feed video signal directly * to the link. */ static bool is_master_pipe_for_link(const struct dc_link *link, const struct pipe_ctx *pipe) { … } /* * This function finds all master pipes feeding to a given link with dpms set to * on in given dc state. */ void link_get_master_pipes_with_dpms_on(const struct dc_link *link, struct dc_state *state, uint8_t *count, struct pipe_ctx *pipes[MAX_PIPES]) { … } static bool get_ext_hdmi_settings(struct pipe_ctx *pipe_ctx, enum engine_id eng_id, struct ext_hdmi_settings *settings) { … } static bool write_i2c(struct pipe_ctx *pipe_ctx, uint8_t address, uint8_t *buffer, uint32_t length) { … } static void write_i2c_retimer_setting( struct pipe_ctx *pipe_ctx, bool is_vga_mode, bool is_over_340mhz, struct ext_hdmi_settings *settings) { … } static void write_i2c_default_retimer_setting( struct pipe_ctx *pipe_ctx, bool is_vga_mode, bool is_over_340mhz) { … } static void write_i2c_redriver_setting( struct pipe_ctx *pipe_ctx, bool is_over_340mhz) { … } static void update_psp_stream_config(struct pipe_ctx *pipe_ctx, bool dpms_off) { … } static void set_avmute(struct pipe_ctx *pipe_ctx, bool enable) { … } static void enable_mst_on_sink(struct dc_link *link, bool enable) { … } static void dsc_optc_config_log(struct display_stream_compressor *dsc, struct dsc_optc_config *config) { … } static bool dp_set_dsc_on_rx(struct pipe_ctx *pipe_ctx, bool enable) { … } /* The stream with these settings can be sent (unblanked) only after DSC was enabled on RX first, * i.e. after dp_enable_dsc_on_rx() had been called */ void link_set_dsc_on_stream(struct pipe_ctx *pipe_ctx, bool enable) { … } /* * For dynamic bpp change case, dsc is programmed with MASTER_UPDATE_LOCK enabled; * hence PPS info packet update need to use frame update instead of immediate update. * Added parameter immediate_update for this purpose. * The decision to use frame update is hard-coded in function dp_update_dsc_config(), * which is the only place where a "false" would be passed in for param immediate_update. * * immediate_update is only applicable when DSC is enabled. */ bool link_set_dsc_pps_packet(struct pipe_ctx *pipe_ctx, bool enable, bool immediate_update) { … } bool link_set_dsc_enable(struct pipe_ctx *pipe_ctx, bool enable) { … } bool link_update_dsc_config(struct pipe_ctx *pipe_ctx) { … } static void enable_stream_features(struct pipe_ctx *pipe_ctx) { … } static void log_vcp_x_y(const struct dc_link *link, struct fixed31_32 avg_time_slots_per_mtp) { … } static struct fixed31_32 get_pbn_per_slot(struct dc_stream_state *stream) { … } static struct fixed31_32 get_pbn_from_bw_in_kbps(uint64_t kbps) { … } static struct fixed31_32 get_pbn_from_timing(struct pipe_ctx *pipe_ctx) { … } // TODO - DP2.0 Link: Fix get_lane_status to handle LTTPR offset (SST and MST) static void get_lane_status( struct dc_link *link, uint32_t lane_count, union lane_status *status, union lane_align_status_updated *status_updated) { … } static bool poll_for_allocation_change_trigger(struct dc_link *link) { … } static void update_mst_stream_alloc_table( struct dc_link *link, struct stream_encoder *stream_enc, struct hpo_dp_stream_encoder *hpo_dp_stream_enc, // TODO: Rename stream_enc to dio_stream_enc? const struct dc_dp_mst_stream_allocation_table *proposed_table) { … } static void remove_stream_from_alloc_table( struct dc_link *link, struct stream_encoder *dio_stream_enc, struct hpo_dp_stream_encoder *hpo_dp_stream_enc) { … } static enum dc_status deallocate_mst_payload(struct pipe_ctx *pipe_ctx) { … } /* convert link_mst_stream_alloc_table to dm dp_mst_stream_alloc_table * because stream_encoder is not exposed to dm */ static enum dc_status allocate_mst_payload(struct pipe_ctx *pipe_ctx) { … } struct fixed31_32 link_calculate_sst_avg_time_slots_per_mtp( const struct dc_stream_state *stream, const struct dc_link *link) { … } static bool write_128b_132b_sst_payload_allocation_table( const struct dc_stream_state *stream, struct dc_link *link, struct link_mst_stream_allocation_table *proposed_table, bool allocate) { … } /* * Payload allocation/deallocation for SST introduced in DP2.0 */ static enum dc_status update_sst_payload(struct pipe_ctx *pipe_ctx, bool allocate) { … } enum dc_status link_reduce_mst_payload(struct pipe_ctx *pipe_ctx, uint32_t bw_in_kbps) { … } enum dc_status link_increase_mst_payload(struct pipe_ctx *pipe_ctx, uint32_t bw_in_kbps) { … } static void disable_link_dp(struct dc_link *link, const struct link_resource *link_res, enum signal_type signal) { … } static void disable_link(struct dc_link *link, const struct link_resource *link_res, enum signal_type signal) { … } static void enable_link_hdmi(struct pipe_ctx *pipe_ctx) { … } static enum dc_status enable_link_dp(struct dc_state *state, struct pipe_ctx *pipe_ctx) { … } static enum dc_status enable_link_edp( struct dc_state *state, struct pipe_ctx *pipe_ctx) { … } static void enable_link_lvds(struct pipe_ctx *pipe_ctx) { … } static enum dc_status enable_link_dp_mst( struct dc_state *state, struct pipe_ctx *pipe_ctx) { … } static enum dc_status enable_link_virtual(struct pipe_ctx *pipe_ctx) { … } static enum dc_status enable_link( struct dc_state *state, struct pipe_ctx *pipe_ctx) { … } static bool allocate_usb4_bandwidth_for_stream(struct dc_stream_state *stream, int bw) { … } static bool allocate_usb4_bandwidth(struct dc_stream_state *stream) { … } static bool deallocate_usb4_bandwidth(struct dc_stream_state *stream) { … } void link_set_dpms_off(struct pipe_ctx *pipe_ctx) { … } void link_set_dpms_on( struct dc_state *state, struct pipe_ctx *pipe_ctx) { … }
Codebase Browser
linux