Skip to contentSkip to conversation

linux-next: manual merge of the amdgpu tree with the drm-misc tree

PATCH Mark Brown 1 participant 1 message Jun 30

Subsystems (4)
lore
Share & tools
lore

Mark Brown

author maintainer
#0 lore raw

Hi all,

Today's linux-next merge of the amdgpu tree got a conflict in:

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c

between commits:

8a0343b03b98a ("drm/amdgpu: Implement "color format" DRM property") 723a2a698fa65 ("drm/amd/display: use DisplayID panel type in dm_set_panel_type")

from the drm-misc tree and commit:

0e967e086e751 ("drm/amd/display: Extract connector and encoder code to amdgpu_dm_connector")

from the amdgpu tree.

I fixed it up (see below) and can carry the fix as necessary. This is now fixed as far as linux-next is concerned, but any non trivial conflicts should be mentioned to your upstream maintainer when your tree is submitted for merging. You may also want to consider cooperating with the maintainer of the conflicting tree to minimise any particularly complex conflicts.

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +0 -0
diff --combined drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index d2dcef74625cc,2e74ff94dcacc..0000000000000
@@@ -66,6 -66,11 +66,11 @@@
  #endif
  #include "amdgpu_dm_psr.h"
  #include "amdgpu_dm_replay.h"
+ #include "amdgpu_dm_backlight.h"
+ #include "amdgpu_dm_audio.h"
+ #include "amdgpu_dm_dmub.h"
+ #include "amdgpu_dm_connector.h"
+ #include "amdgpu_dm_kunit_helpers.h"
  
  #include "ivsrcid/ivsrcid_vislands30.h"
  
@@@ -94,7 -99,6 +99,6 @@@
  #include <drm/drm_mode.h>
  #include <drm/drm_utils.h>
  #include <drm/drm_vblank.h>
- #include <drm/drm_audio_component.h>
  #include <drm/drm_colorop.h>
  #include <drm/drm_gem_atomic_helper.h>
  
@@@ -107,60 -111,9 +111,9 @@@
  #include "modules/inc/mod_power.h"
  #include "modules/power/power_helpers.h"
  
- static_assert(AMDGPU_DMUB_NOTIFICATION_MAX == DMUB_NOTIFICATION_MAX, "AMDGPU_DMUB_NOTIFICATION_MAX mismatch");
- 
- #define FIRMWARE_RENOIR_DMUB "amdgpu/renoir_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_RENOIR_DMUB);
- #define FIRMWARE_SIENNA_CICHLID_DMUB "amdgpu/sienna_cichlid_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_SIENNA_CICHLID_DMUB);
- #define FIRMWARE_NAVY_FLOUNDER_DMUB "amdgpu/navy_flounder_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_NAVY_FLOUNDER_DMUB);
- #define FIRMWARE_GREEN_SARDINE_DMUB "amdgpu/green_sardine_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_GREEN_SARDINE_DMUB);
- #define FIRMWARE_VANGOGH_DMUB "amdgpu/vangogh_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_VANGOGH_DMUB);
- #define FIRMWARE_DIMGREY_CAVEFISH_DMUB "amdgpu/dimgrey_cavefish_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DIMGREY_CAVEFISH_DMUB);
- #define FIRMWARE_BEIGE_GOBY_DMUB "amdgpu/beige_goby_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_BEIGE_GOBY_DMUB);
- #define FIRMWARE_YELLOW_CARP_DMUB "amdgpu/yellow_carp_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_YELLOW_CARP_DMUB);
- #define FIRMWARE_DCN_314_DMUB "amdgpu/dcn_3_1_4_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_314_DMUB);
- #define FIRMWARE_DCN_315_DMUB "amdgpu/dcn_3_1_5_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_315_DMUB);
- #define FIRMWARE_DCN316_DMUB "amdgpu/dcn_3_1_6_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN316_DMUB);
- 
- #define FIRMWARE_DCN_V3_2_0_DMCUB "amdgpu/dcn_3_2_0_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_V3_2_0_DMCUB);
- #define FIRMWARE_DCN_V3_2_1_DMCUB "amdgpu/dcn_3_2_1_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_V3_2_1_DMCUB);
- 
- #define FIRMWARE_RAVEN_DMCU		"amdgpu/raven_dmcu.bin"
  MODULE_FIRMWARE(FIRMWARE_RAVEN_DMCU);
- 
- #define FIRMWARE_NAVI12_DMCU            "amdgpu/navi12_dmcu.bin"
  MODULE_FIRMWARE(FIRMWARE_NAVI12_DMCU);
  
- #define FIRMWARE_DCN_35_DMUB "amdgpu/dcn_3_5_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_35_DMUB);
- 
- #define FIRMWARE_DCN_351_DMUB "amdgpu/dcn_3_5_1_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_351_DMUB);
- 
- #define FIRMWARE_DCN_36_DMUB "amdgpu/dcn_3_6_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_36_DMUB);
- 
- #define FIRMWARE_DCN_401_DMUB "amdgpu/dcn_4_0_1_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_401_DMUB);
- 
- #define FIRMWARE_DCN_42_DMUB "amdgpu/dcn_4_2_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_42_DMUB);
- 
- #define FIRMWARE_DCN_42B_DMUB "amdgpu/dcn_4_2_1_dmcub.bin"
- MODULE_FIRMWARE(FIRMWARE_DCN_42B_DMUB);
- 
  /**
   * DOC: overview
   *
@@@ -174,46 -127,7 +127,7 @@@
  /* basic init/fini API */
  static int amdgpu_dm_init(struct amdgpu_device *adev);
  static void amdgpu_dm_fini(struct amdgpu_device *adev);
- static bool is_freesync_video_mode(const struct drm_display_mode *mode, struct amdgpu_dm_connector *aconnector);
  static void reset_freesync_config_for_crtc(struct dm_crtc_state *new_crtc_state);
- static struct amdgpu_i2c_adapter *
- create_i2c(struct ddc_service *ddc_service, bool oem);
- 
- static enum drm_mode_subconnector get_subconnector_type(struct dc_link *link)
- {
- 	switch (link->dpcd_caps.dongle_type) {
- 	case DISPLAY_DONGLE_NONE:
- 		return DRM_MODE_SUBCONNECTOR_Native;
- 	case DISPLAY_DONGLE_DP_VGA_CONVERTER:
- 		return DRM_MODE_SUBCONNECTOR_VGA;
- 	case DISPLAY_DONGLE_DP_DVI_CONVERTER:
- 	case DISPLAY_DONGLE_DP_DVI_DONGLE:
- 		return DRM_MODE_SUBCONNECTOR_DVID;
- 	case DISPLAY_DONGLE_DP_HDMI_CONVERTER:
- 	case DISPLAY_DONGLE_DP_HDMI_DONGLE:
- 		return DRM_MODE_SUBCONNECTOR_HDMIA;
- 	case DISPLAY_DONGLE_DP_HDMI_MISMATCHED_DONGLE:
- 	default:
- 		return DRM_MODE_SUBCONNECTOR_Unknown;
- 	}
- }
- 
- static void update_subconnector_property(struct amdgpu_dm_connector *aconnector)
- {
- 	struct dc_link *link = aconnector->dc_link;
- 	struct drm_connector *connector = &aconnector->base;
- 	enum drm_mode_subconnector subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
- 
- 	if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
- 		return;
- 
- 	if (aconnector->dc_sink)
- 		subconnector = get_subconnector_type(link);
- 
- 	drm_object_property_set_value(&connector->base,
- 			connector->dev->mode_config.dp_subconnector_property,
- 			subconnector);
- }
  
  /*
   * initializes drm_device display related structures, based on the information
@@@ -226,32 -140,23 +140,23 @@@ static int amdgpu_dm_initialize_drm_dev
  /* removes and deallocates the drm structures, created by the above function */
  static void amdgpu_dm_destroy_drm_device(struct amdgpu_display_manager *dm);
  
- static int amdgpu_dm_connector_init(struct amdgpu_display_manager *dm,
- 				    struct amdgpu_dm_connector *amdgpu_dm_connector,
- 				    u32 link_index,
- 				    struct amdgpu_encoder *amdgpu_encoder);
- static int amdgpu_dm_encoder_init(struct drm_device *dev,
- 				  struct amdgpu_encoder *aencoder,
- 				  uint32_t link_index);
- 
- static int amdgpu_dm_connector_get_modes(struct drm_connector *connector);
- 
  static int amdgpu_dm_atomic_setup_commit(struct drm_atomic_commit *state);
  static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_commit *state);
+ static void dm_enable_per_frame_crtc_master_sync(struct dc_state *context);
  
  static int amdgpu_dm_atomic_check(struct drm_device *dev,
  				  struct drm_atomic_commit *state);
  
- static void handle_hpd_irq_helper(struct amdgpu_dm_connector *aconnector);
- static void handle_hpd_rx_irq(void *param);
- 
- static void amdgpu_dm_backlight_set_level(struct amdgpu_display_manager *dm,
- 					 int bl_idx,
- 					 u32 user_brightness);
- 
- static bool
+ STATIC_IFN_KUNIT bool
  is_timing_unchanged_for_freesync(struct drm_crtc_state *old_crtc_state,
  				 struct drm_crtc_state *new_crtc_state);
+ 
+ static inline void amdgpu_dm_exit_ips_for_hw_access(struct dc *dc)
+ {
+ 	if (dc->ctx->dmub_srv && !dc->ctx->dmub_srv->idle_exit_counter)
+ 		dc_exit_ips_for_hw_access(dc);
+ }
+ 
  /*
   * dm_vblank_get_counter
   *
@@@ -343,29 -248,8 +248,8 @@@ static int dm_soft_reset(struct amdgpu_
  	return 0;
  }
  
- static struct amdgpu_crtc *
- get_crtc_by_otg_inst(struct amdgpu_device *adev,
- 		     int otg_inst)
- {
- 	struct drm_device *dev = adev_to_drm(adev);
- 	struct drm_crtc *crtc;
- 	struct amdgpu_crtc *amdgpu_crtc;
- 
- 	if (WARN_ON(otg_inst == -1))
- 		return adev->mode_info.crtcs[0];
- 
- 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
- 		amdgpu_crtc = to_amdgpu_crtc(crtc);
- 
- 		if (amdgpu_crtc->otg_inst == otg_inst)
- 			return amdgpu_crtc;
- 	}
- 
- 	return NULL;
- }
- 
- static inline bool is_dc_timing_adjust_needed(struct dm_crtc_state *old_state,
- 					      struct dm_crtc_state *new_state)
+ STATIC_IFN_KUNIT bool is_dc_timing_adjust_needed(struct dm_crtc_state *old_state,
+ 						 struct dm_crtc_state *new_state)
  {
  	if (new_state->stream->adjust.timing_adjust_pending)
  		return true;
@@@ -376,13 -260,14 +260,14 @@@
  	else
  		return false;
  }
+ EXPORT_IF_KUNIT(is_dc_timing_adjust_needed);
  
  /*
   * DC will program planes with their z-order determined by their ordering
   * in the dc_surface_updates array. This comparator is used to sort them
   * by descending zpos.
   */
- static int dm_plane_layer_index_cmp(const void *a, const void *b)
+ STATIC_IFN_KUNIT int dm_plane_layer_index_cmp(const void *a, const void *b)
  {
  	const struct dc_surface_update *sa = (struct dc_surface_update *)a;
  	const struct dc_surface_update *sb = (struct dc_surface_update *)b;
@@@ -390,6 -275,7 +275,7 @@@
  	/* Sort by descending dc_plane layer_index (i.e. normalized_zpos) */
  	return sb->surface->layer_index - sa->surface->layer_index;
  }
+ EXPORT_IF_KUNIT(dm_plane_layer_index_cmp);
  
  /**
   * update_planes_and_stream_adapter() - Send planes to be updated in DC
@@@ -430,633 -316,6 +316,6 @@@ static inline bool update_planes_and_st
  					   stream_update);
  }
  
- /**
-  * dm_pflip_high_irq() - Handle pageflip interrupt
-  * @interrupt_params: ignored
-  *
-  * Handles the pageflip interrupt by notifying all interested parties
-  * that the pageflip has been completed.
-  */
- static void dm_pflip_high_irq(void *interrupt_params)
- {
- 	struct amdgpu_crtc *amdgpu_crtc;
- 	struct common_irq_params *irq_params = interrupt_params;
- 	struct amdgpu_device *adev = irq_params->adev;
- 	struct drm_device *dev = adev_to_drm(adev);
- 	unsigned long flags;
- 	struct drm_pending_vblank_event *e;
- 	u32 vpos, hpos, v_blank_start, v_blank_end;
- 	bool vrr_active;
- 
- 	amdgpu_crtc = get_crtc_by_otg_inst(adev, irq_params->irq_src - IRQ_TYPE_PFLIP);
- 
- 	/* IRQ could occur when in initial stage */
- 	/* TODO work and BO cleanup */
- 	if (amdgpu_crtc == NULL) {
- 		drm_dbg_state(dev, "CRTC is null, returning.\n");
- 		return;
- 	}
- 
- 	spin_lock_irqsave(&adev_to_drm(adev)->event_lock, flags);
- 
- 	if (amdgpu_crtc->pflip_status != AMDGPU_FLIP_SUBMITTED) {
- 		drm_dbg_state(dev,
- 			      "amdgpu_crtc->pflip_status = %d != AMDGPU_FLIP_SUBMITTED(%d) on crtc:%d[%p]\n",
- 			      amdgpu_crtc->pflip_status, AMDGPU_FLIP_SUBMITTED,
- 			      amdgpu_crtc->crtc_id, amdgpu_crtc);
- 		spin_unlock_irqrestore(&adev_to_drm(adev)->event_lock, flags);
- 		return;
- 	}
- 
- 	/* page flip completed. */
- 	e = amdgpu_crtc->event;
- 	amdgpu_crtc->event = NULL;
- 
- 	WARN_ON(!e);
- 
- 	vrr_active = amdgpu_dm_crtc_vrr_active_irq(amdgpu_crtc);
- 
- 	/* Fixed refresh rate, or VRR scanout position outside front-porch? */
- 	if (!vrr_active ||
- 	    !dc_stream_get_scanoutpos(amdgpu_crtc->dm_irq_params.stream, &v_blank_start,
- 				      &v_blank_end, &hpos, &vpos) ||
- 	    (vpos < v_blank_start)) {
- 		/* Update to correct count and vblank timestamp if racing with
- 		 * vblank irq. This also updates to the correct vblank timestamp
- 		 * even in VRR mode, as scanout is past the front-porch atm.
- 		 */
- 		drm_crtc_accurate_vblank_count(&amdgpu_crtc->base);
- 
- 		/* Wake up userspace by sending the pageflip event with proper
- 		 * count and timestamp of vblank of flip completion.
- 		 */
- 		if (e) {
- 			drm_crtc_send_vblank_event(&amdgpu_crtc->base, e);
- 
- 			/* Event sent, so done with vblank for this flip */
- 			drm_crtc_vblank_put(&amdgpu_crtc->base);
- 		}
- 	} else if (e) {
- 		/* VRR active and inside front-porch: vblank count and
- 		 * timestamp for pageflip event will only be up to date after
- 		 * drm_crtc_handle_vblank() has been executed from late vblank
- 		 * irq handler after start of back-porch (vline 0). We queue the
- 		 * pageflip event for send-out by drm_crtc_handle_vblank() with
- 		 * updated timestamp and count, once it runs after us.
- 		 *
- 		 * We need to open-code this instead of using the helper
- 		 * drm_crtc_arm_vblank_event(), as that helper would
- 		 * call drm_crtc_accurate_vblank_count(), which we must
- 		 * not call in VRR mode while we are in front-porch!
- 		 */
- 
- 		/* sequence will be replaced by real count during send-out. */
- 		e->sequence = drm_crtc_vblank_count(&amdgpu_crtc->base);
- 		e->pipe = amdgpu_crtc->crtc_id;
- 
- 		list_add_tail(&e->base.link, &adev_to_drm(adev)->vblank_event_list);
- 		e = NULL;
- 	}
- 
- 	/* Keep track of vblank of this flip for flip throttling. We use the
- 	 * cooked hw counter, as that one incremented at start of this vblank
- 	 * of pageflip completion, so last_flip_vblank is the forbidden count
- 	 * for queueing new pageflips if vsync + VRR is enabled.
- 	 */
- 	amdgpu_crtc->dm_irq_params.last_flip_vblank =
- 		amdgpu_get_vblank_counter_kms(&amdgpu_crtc->base);
- 
- 	amdgpu_crtc->pflip_status = AMDGPU_FLIP_NONE;
- 	spin_unlock_irqrestore(&adev_to_drm(adev)->event_lock, flags);
- 
- 	drm_dbg_state(dev,
- 		      "crtc:%d[%p], pflip_stat:AMDGPU_FLIP_NONE, vrr[%d]-fp %d\n",
- 		      amdgpu_crtc->crtc_id, amdgpu_crtc, vrr_active, (int)!e);
- }
- 
- static void dm_handle_vmin_vmax_update(struct work_struct *offload_work)
- {
- 	struct vupdate_offload_work *work = container_of(offload_work, struct vupdate_offload_work, work);
- 	struct amdgpu_device *adev = work->adev;
- 	struct dc_stream_state *stream = work->stream;
- 	struct dc_crtc_timing_adjust *adjust = work->adjust;
- 
- 	mutex_lock(&adev->dm.dc_lock);
- 	dc_stream_adjust_vmin_vmax(adev->dm.dc, stream, adjust);
- 	mutex_unlock(&adev->dm.dc_lock);
- 
- 	dc_stream_release(stream);
- 	kfree(work->adjust);
- 	kfree(work);
- }
- 
- static void schedule_dc_vmin_vmax(struct amdgpu_device *adev,
- 	struct dc_stream_state *stream,
- 	struct dc_crtc_timing_adjust *adjust)
- {
- 	struct vupdate_offload_work *offload_work = kzalloc_obj(*offload_work,
- 								GFP_NOWAIT);
- 	if (!offload_work) {
- 		drm_dbg_driver(adev_to_drm(adev), "Failed to allocate vupdate_offload_work\n");
- 		return;
- 	}
- 
- 	struct dc_crtc_timing_adjust *adjust_copy = kzalloc_obj(*adjust_copy,
- 								GFP_NOWAIT);
- 	if (!adjust_copy) {
- 		drm_dbg_driver(adev_to_drm(adev), "Failed to allocate adjust_copy\n");
- 		kfree(offload_work);
- 		return;
- 	}
- 
- 	dc_stream_retain(stream);
- 	memcpy(adjust_copy, adjust, sizeof(*adjust_copy));
- 
- 	INIT_WORK(&offload_work->work, dm_handle_vmin_vmax_update);
- 	offload_work->adev = adev;
- 	offload_work->stream = stream;
- 	offload_work->adjust = adjust_copy;
- 
- 	queue_work(system_percpu_wq, &offload_work->work);
- }
- 
- static void dm_vupdate_high_irq(void *interrupt_params)
- {
- 	struct common_irq_params *irq_params = interrupt_params;
- 	struct amdgpu_device *adev = irq_params->adev;
- 	struct amdgpu_crtc *acrtc;
- 	struct drm_device *drm_dev;
- 	struct drm_vblank_crtc *vblank;
- 	ktime_t frame_duration_ns, previous_timestamp;
- 	unsigned long flags;
- 	int vrr_active;
- 
- 	acrtc = get_crtc_by_otg_inst(adev, irq_params->irq_src - IRQ_TYPE_VUPDATE);
- 
- 	if (acrtc) {
- 		vrr_active = amdgpu_dm_crtc_vrr_active_irq(acrtc);
- 		drm_dev = acrtc->base.dev;
- 		vblank = drm_crtc_vblank_crtc(&acrtc->base);
- 		previous_timestamp = atomic64_read(&irq_params->previous_timestamp);
- 		frame_duration_ns = vblank->time - previous_timestamp;
- 
- 		if (frame_duration_ns > 0) {
- 			trace_amdgpu_refresh_rate_track(acrtc->base.index,
- 						frame_duration_ns,
- 						ktime_divns(NSEC_PER_SEC, frame_duration_ns));
- 			atomic64_set(&irq_params->previous_timestamp, vblank->time);
- 		}
- 
- 		drm_dbg_vbl(drm_dev,
- 			    "crtc:%d, vupdate-vrr:%d\n", acrtc->crtc_id,
- 			    vrr_active);
- 
- 		/* Core vblank handling is done here after end of front-porch in
- 		 * vrr mode, as vblank timestamping will give valid results
- 		 * while now done after front-porch. This will also deliver
- 		 * page-flip completion events that have been queued to us
- 		 * if a pageflip happened inside front-porch.
- 		 */
- 		if (vrr_active && acrtc->dm_irq_params.stream) {
- 			bool replay_en = acrtc->dm_irq_params.stream->link->replay_settings.replay_feature_enabled;
- 			bool psr_en = acrtc->dm_irq_params.stream->link->psr_settings.psr_feature_enabled;
- 			bool fs_active_var_en = acrtc->dm_irq_params.freesync_config.state
- 				== VRR_STATE_ACTIVE_VARIABLE;
- 
- 			amdgpu_dm_crtc_handle_vblank(acrtc);
- 
- 			/* BTR processing for pre-DCE12 ASICs */
- 			if (adev->family < AMDGPU_FAMILY_AI) {
- 				spin_lock_irqsave(&adev_to_drm(adev)->event_lock, flags);
- 				mod_freesync_handle_v_update(
- 				    adev->dm.freesync_module,
- 				    acrtc->dm_irq_params.stream,
- 				    &acrtc->dm_irq_params.vrr_params);
- 
- 				if (fs_active_var_en || (!fs_active_var_en && !replay_en && !psr_en)) {
- 					schedule_dc_vmin_vmax(adev,
- 						acrtc->dm_irq_params.stream,
- 						&acrtc->dm_irq_params.vrr_params.adjust);
- 				}
- 				spin_unlock_irqrestore(&adev_to_drm(adev)->event_lock, flags);
- 			}
- 		}
- 	}
- }
- 
- /**
-  * dm_crtc_high_irq() - Handles CRTC interrupt
-  * @interrupt_params: used for determining the CRTC instance
-  *
-  * Handles the CRTC/VSYNC interrupt by notfying DRM's VBLANK
-  * event handler.
-  */
- static void dm_crtc_high_irq(void *interrupt_params)
- {
- 	struct common_irq_params *irq_params = interrupt_params;
- 	struct amdgpu_device *adev = irq_params->adev;
- 	struct drm_writeback_job *job;
- 	struct amdgpu_crtc *acrtc;
- 	unsigned long flags;
- 	int vrr_active;
- 
- 	acrtc = get_crtc_by_otg_inst(adev, irq_params->irq_src - IRQ_TYPE_VBLANK);
- 	if (!acrtc)
- 		return;
- 
- 	if (acrtc->wb_conn) {
- 		spin_lock_irqsave(&acrtc->wb_conn->job_lock, flags);
- 
- 		if (acrtc->wb_pending) {
- 			job = list_first_entry_or_null(&acrtc->wb_conn->job_queue,
- 						       struct drm_writeback_job,
- 						       list_entry);
- 			acrtc->wb_pending = false;
- 			spin_unlock_irqrestore(&acrtc->wb_conn->job_lock, flags);
- 
- 			if (job) {
- 				unsigned int v_total, refresh_hz;
- 				struct dc_stream_state *stream = acrtc->dm_irq_params.stream;
- 
- 				v_total = stream->adjust.v_total_max ?
- 					  stream->adjust.v_total_max : stream->timing.v_total;
- 				refresh_hz = div_u64((uint64_t) stream->timing.pix_clk_100hz *
- 					     100LL, (v_total * stream->timing.h_total));
- 				mdelay(1000 / refresh_hz);
- 
- 				drm_writeback_signal_completion(acrtc->wb_conn, 0);
- 				dc_stream_fc_disable_writeback(adev->dm.dc,
- 							       acrtc->dm_irq_params.stream, 0);
- 			}
- 		} else
- 			spin_unlock_irqrestore(&acrtc->wb_conn->job_lock, flags);
- 	}
- 
- 	vrr_active = amdgpu_dm_crtc_vrr_active_irq(acrtc);
- 
- 	drm_dbg_vbl(adev_to_drm(adev),
- 		    "crtc:%d, vupdate-vrr:%d, planes:%d\n", acrtc->crtc_id,
- 		    vrr_active, acrtc->dm_irq_params.active_planes);
- 
- 	/**
- 	 * Core vblank handling at start of front-porch is only possible
- 	 * in non-vrr mode, as only there vblank timestamping will give
- 	 * valid results while done in front-porch. Otherwise defer it
- 	 * to dm_vupdate_high_irq after end of front-porch.
- 	 */
- 	if (!vrr_active)
- 		amdgpu_dm_crtc_handle_vblank(acrtc);
- 
- 	/**
- 	 * Following stuff must happen at start of vblank, for crc
- 	 * computation and below-the-range btr support in vrr mode.
- 	 */
- 	amdgpu_dm_crtc_handle_crc_irq(&acrtc->base);
- 
- 	/* BTR updates need to happen before VUPDATE on Vega and above. */
- 	if (adev->family < AMDGPU_FAMILY_AI)
- 		return;
- 
- 	spin_lock_irqsave(&adev_to_drm(adev)->event_lock, flags);
- 
- 	if (acrtc->dm_irq_params.stream &&
- 		acrtc->dm_irq_params.vrr_params.supported) {
- 		bool replay_en = acrtc->dm_irq_params.stream->link->replay_settings.replay_feature_enabled;
- 		bool psr_en = acrtc->dm_irq_params.stream->link->psr_settings.psr_feature_enabled;
- 		bool fs_active_var_en = acrtc->dm_irq_params.freesync_config.state == VRR_STATE_ACTIVE_VARIABLE;
- 
- 		mod_freesync_handle_v_update(adev->dm.freesync_module,
- 					     acrtc->dm_irq_params.stream,
- 					     &acrtc->dm_irq_params.vrr_params);
- 
- 		/* update vmin_vmax only if freesync is enabled, or only if PSR and REPLAY are disabled */
- 		if (fs_active_var_en || (!fs_active_var_en && !replay_en && !psr_en)) {
- 			schedule_dc_vmin_vmax(adev, acrtc->dm_irq_params.stream,
- 					&acrtc->dm_irq_params.vrr_params.adjust);
- 		}
- 	}
- 
- 	/*
- 	 * If there aren't any active_planes then DCH HUBP may be clock-gated.
- 	 * In that case, pageflip completion interrupts won't fire and pageflip
- 	 * completion events won't get delivered. Prevent this by sending
- 	 * pending pageflip events from here if a flip is still pending.
- 	 *
- 	 * If any planes are enabled, use dm_pflip_high_irq() instead, to
- 	 * avoid race conditions between flip programming and completion,
- 	 * which could cause too early flip completion events.
- 	 */
- 	if (adev->family >= AMDGPU_FAMILY_RV &&
- 	    acrtc->pflip_status == AMDGPU_FLIP_SUBMITTED &&
- 	    acrtc->dm_irq_params.active_planes == 0) {
- 		if (acrtc->event) {
- 			drm_crtc_send_vblank_event(&acrtc->base, acrtc->event);
- 			acrtc->event = NULL;
- 			drm_crtc_vblank_put(&acrtc->base);
- 		}
- 		acrtc->pflip_status = AMDGPU_FLIP_NONE;
- 	}
- 
- 	spin_unlock_irqrestore(&adev_to_drm(adev)->event_lock, flags);
- }
- 
- #if defined(CONFIG_DRM_AMD_SECURE_DISPLAY)
- /**
-  * dm_dcn_vertical_interrupt0_high_irq() - Handles OTG Vertical interrupt0 for
-  * DCN generation ASICs
-  * @interrupt_params: interrupt parameters
-  *
-  * Used to set crc window/read out crc value at vertical line 0 position
-  */
- static void dm_dcn_vertical_interrupt0_high_irq(void *interrupt_params)
- {
- 	struct common_irq_params *irq_params = interrupt_params;
- 	struct amdgpu_device *adev = irq_params->adev;
- 	struct amdgpu_crtc *acrtc;
- 
- 	acrtc = get_crtc_by_otg_inst(adev, irq_params->irq_src - IRQ_TYPE_VLINE0);
- 
- 	if (!acrtc)
- 		return;
- 
- 	amdgpu_dm_crtc_handle_crc_window_irq(&acrtc->base);
- }
- #endif /* CONFIG_DRM_AMD_SECURE_DISPLAY */
- 
- /**
-  * dmub_aux_setconfig_callback - Callback for AUX or SET_CONFIG command.
-  * @adev: amdgpu_device pointer
-  * @notify: dmub notification structure
-  *
-  * Dmub AUX or SET_CONFIG command completion processing callback
-  * Copies dmub notification to DM which is to be read by AUX command.
-  * issuing thread and also signals the event to wake up the thread.
-  */
- static void dmub_aux_setconfig_callback(struct amdgpu_device *adev,
- 					struct dmub_notification *notify)
- {
- 	if (adev->dm.dmub_notify)
- 		memcpy(adev->dm.dmub_notify, notify, sizeof(struct dmub_notification));
- 	if (notify->type == DMUB_NOTIFICATION_AUX_REPLY)
- 		complete(&adev->dm.dmub_aux_transfer_done);
- }
- 
- static void dmub_aux_fused_io_callback(struct amdgpu_device *adev,
- 					struct dmub_notification *notify)
- {
- 	if (!adev || !notify) {
- 		ASSERT(false);
- 		return;
- 	}
- 
- 	const struct dmub_cmd_fused_request *req = &notify->fused_request;
- 	const uint8_t ddc_line = req->u.aux.ddc_line;
- 
- 	if (ddc_line >= ARRAY_SIZE(adev->dm.fused_io)) {
- 		ASSERT(false);
- 		return;
- 	}
- 
- 	struct fused_io_sync *sync = &adev->dm.fused_io[ddc_line];
- 
- 	static_assert(sizeof(*req) <= sizeof(sync->reply_data), "Size mismatch");
- 	memcpy(sync->reply_data, req, sizeof(*req));
- 	complete(&sync->replied);
- }
- 
- /**
-  * dmub_hpd_callback - DMUB HPD interrupt processing callback.
-  * @adev: amdgpu_device pointer
-  * @notify: dmub notification structure
-  *
-  * Dmub Hpd interrupt processing callback. Gets displayindex through the
-  * ink index and calls helper to do the processing.
-  */
- static void dmub_hpd_callback(struct amdgpu_device *adev,
- 			      struct dmub_notification *notify)
- {
- 	struct amdgpu_dm_connector *aconnector;
- 	struct amdgpu_dm_connector *hpd_aconnector = NULL;
- 	struct drm_connector *connector;
- 	struct drm_connector_list_iter iter;
- 	struct dc_link *link;
- 	u8 link_index = 0;
- 	struct drm_device *dev;
- 
- 	if (adev == NULL)
- 		return;
- 
- 	if (notify == NULL) {
- 		drm_err(adev_to_drm(adev), "DMUB HPD callback notification was NULL");
- 		return;
- 	}
- 
- 	if (notify->link_index > adev->dm.dc->link_count) {
- 		drm_err(adev_to_drm(adev), "DMUB HPD index (%u)is abnormal", notify->link_index);
- 		return;
- 	}
- 
- 	/* Skip DMUB HPD IRQ in suspend/resume. We will probe them later. */
- 	if (notify->type == DMUB_NOTIFICATION_HPD && adev->in_suspend) {
- 		drm_info(adev_to_drm(adev), "Skip DMUB HPD IRQ callback in suspend/resume\n");
- 		return;
- 	}
- 
- 	link_index = notify->link_index;
- 	link = adev->dm.dc->links[link_index];
- 	dev = adev->dm.ddev;
- 
- 	drm_connector_list_iter_begin(dev, &iter);
- 	drm_for_each_connector_iter(connector, &iter) {
- 
- 		if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
- 			continue;
- 
- 		aconnector = to_amdgpu_dm_connector(connector);
- 		if (link && aconnector->dc_link == link) {
- 			if (notify->type == DMUB_NOTIFICATION_HPD)
- 				drm_info(adev_to_drm(adev), "DMUB HPD IRQ callback: link_index=%u\n", link_index);
- 			else if (notify->type == DMUB_NOTIFICATION_HPD_IRQ)
- 				drm_info(adev_to_drm(adev), "DMUB HPD RX IRQ callback: link_index=%u\n", link_index);
- 			else
- 				drm_warn(adev_to_drm(adev), "DMUB Unknown HPD callback type %d, link_index=%u\n",
- 						notify->type, link_index);
- 
- 			hpd_aconnector = aconnector;
- 			break;
- 		}
- 	}
- 	drm_connector_list_iter_end(&iter);
- 
- 	if (hpd_aconnector) {
- 		if (notify->type == DMUB_NOTIFICATION_HPD) {
- 			if (hpd_aconnector->dc_link->hpd_status == (notify->hpd_status == DP_HPD_PLUG))
- 				drm_warn(adev_to_drm(adev), "DMUB reported hpd status unchanged. link_index=%u\n", link_index);
- 			handle_hpd_irq_helper(hpd_aconnector);
- 		} else if (notify->type == DMUB_NOTIFICATION_HPD_IRQ) {
- 			handle_hpd_rx_irq(hpd_aconnector);
- 		}
- 	}
- }
- 
- /**
-  * dmub_hpd_sense_callback - DMUB HPD sense processing callback.
-  * @adev: amdgpu_device pointer
-  * @notify: dmub notification structure
-  *
-  * HPD sense changes can occur during low power states and need to be
-  * notified from firmware to driver.
-  */
- static void dmub_hpd_sense_callback(struct amdgpu_device *adev,
- 			      struct dmub_notification *notify)
- {
- 	drm_dbg_driver(adev_to_drm(adev), "DMUB HPD SENSE callback.\n");
- }
- 
- /**
-  * register_dmub_notify_callback - Sets callback for DMUB notify
-  * @adev: amdgpu_device pointer
-  * @type: Type of dmub notification
-  * @callback: Dmub interrupt callback function
-  * @dmub_int_thread_offload: offload indicator
-  *
-  * API to register a dmub callback handler for a dmub notification
-  * Also sets indicator whether callback processing to be offloaded.
-  * to dmub interrupt handling thread
-  * Return: true if successfully registered, false if there is existing registration
-  */
- static bool register_dmub_notify_callback(struct amdgpu_device *adev,
- 					  enum dmub_notification_type type,
- 					  dmub_notify_interrupt_callback_t callback,
- 					  bool dmub_int_thread_offload)
- {
- 	if (callback != NULL && type < ARRAY_SIZE(adev->dm.dmub_thread_offload)) {
- 		adev->dm.dmub_callback[type] = callback;
- 		adev->dm.dmub_thread_offload[type] = dmub_int_thread_offload;
- 	} else
- 		return false;
- 
- 	return true;
- }
- 
- static void dm_handle_hpd_work(struct work_struct *work)
- {
- 	struct dmub_hpd_work *dmub_hpd_wrk;
- 
- 	dmub_hpd_wrk = container_of(work, struct dmub_hpd_work, handle_hpd_work);
- 
- 	if (!dmub_hpd_wrk->dmub_notify) {
- 		drm_err(adev_to_drm(dmub_hpd_wrk->adev), "dmub_hpd_wrk dmub_notify is NULL");
- 		return;
- 	}
- 
- 	if (dmub_hpd_wrk->dmub_notify->type < ARRAY_SIZE(dmub_hpd_wrk->adev->dm.dmub_callback)) {
- 		dmub_hpd_wrk->adev->dm.dmub_callback[dmub_hpd_wrk->dmub_notify->type](dmub_hpd_wrk->adev,
- 		dmub_hpd_wrk->dmub_notify);
- 	}
- 
- 	kfree(dmub_hpd_wrk->dmub_notify);
- 	kfree(dmub_hpd_wrk);
- 
- }
- 
- static const char *dmub_notification_type_str(enum dmub_notification_type e)
- {
- 	switch (e) {
- 	case DMUB_NOTIFICATION_NO_DATA:
- 		return "NO_DATA";
- 	case DMUB_NOTIFICATION_AUX_REPLY:
- 		return "AUX_REPLY";
- 	case DMUB_NOTIFICATION_HPD:
- 		return "HPD";
- 	case DMUB_NOTIFICATION_HPD_IRQ:
- 		return "HPD_IRQ";
- 	case DMUB_NOTIFICATION_SET_CONFIG_REPLY:
- 		return "SET_CONFIG_REPLY";
- 	case DMUB_NOTIFICATION_DPIA_NOTIFICATION:
- 		return "DPIA_NOTIFICATION";
- 	case DMUB_NOTIFICATION_HPD_SENSE_NOTIFY:
- 		return "HPD_SENSE_NOTIFY";
- 	case DMUB_NOTIFICATION_FUSED_IO:
- 		return "FUSED_IO";
- 	default:
- 		return "<unknown>";
- 	}
- }
- 
- #define DMUB_TRACE_MAX_READ 64
- /**
-  * dm_dmub_outbox1_low_irq() - Handles Outbox interrupt
-  * @interrupt_params: used for determining the Outbox instance
-  *
-  * Handles the Outbox Interrupt
-  * event handler.
-  */
- static void dm_dmub_outbox1_low_irq(void *interrupt_params)
- {
- 	struct dmub_notification notify = {0};
- 	struct common_irq_params *irq_params = interrupt_params;
- 	struct amdgpu_device *adev = irq_params->adev;
- 	struct amdgpu_display_manager *dm = &adev->dm;
- 	struct dmcub_trace_buf_entry entry = { 0 };
- 	u32 count = 0;
- 	struct dmub_hpd_work *dmub_hpd_wrk;
- 
- 	do {
- 		if (dc_dmub_srv_get_dmub_outbox0_msg(dm->dc, &entry)) {
- 			trace_amdgpu_dmub_trace_high_irq(entry.trace_code, entry.tick_count,
- 							entry.param0, entry.param1);
- 
- 			drm_dbg_driver(adev_to_drm(adev), "trace_code:%u, tick_count:%u, param0:%u, param1:%u\n",
- 				 entry.trace_code, entry.tick_count, entry.param0, entry.param1);
- 		} else
- 			break;
- 
- 		count++;
- 
- 	} while (count <= DMUB_TRACE_MAX_READ);
- 
- 	if (count > DMUB_TRACE_MAX_READ)
- 		drm_dbg_driver(adev_to_drm(adev), "Warning : count > DMUB_TRACE_MAX_READ");
- 
- 	if (dc_enable_dmub_notifications(adev->dm.dc) &&
- 		irq_params->irq_src == DC_IRQ_SOURCE_DMCUB_OUTBOX) {
- 
- 		do {
- 			dc_stat_get_dmub_notification(adev->dm.dc, &notify);
- 			if (notify.type >= ARRAY_SIZE(dm->dmub_thread_offload)) {
- 				drm_err(adev_to_drm(adev), "DM: notify type %d invalid!", notify.type);
- 				continue;
- 			}
- 			if (!dm->dmub_callback[notify.type]) {
- 				drm_warn(adev_to_drm(adev), "DMUB notification skipped due to no handler: type=%s\n",
- 					dmub_notification_type_str(notify.type));
- 				continue;
- 			}
- 			if (dm->dmub_thread_offload[notify.type] == true) {
- 				dmub_hpd_wrk = kzalloc_obj(*dmub_hpd_wrk,
- 							   GFP_ATOMIC);
- 				if (!dmub_hpd_wrk) {
- 					drm_err(adev_to_drm(adev), "Failed to allocate dmub_hpd_wrk");
- 					return;
- 				}
- 				dmub_hpd_wrk->dmub_notify = kmemdup(&notify, sizeof(struct dmub_notification),
- 								    GFP_ATOMIC);
- 				if (!dmub_hpd_wrk->dmub_notify) {
- 					kfree(dmub_hpd_wrk);
- 					drm_err(adev_to_drm(adev), "Failed to allocate dmub_hpd_wrk->dmub_notify");
- 					return;
- 				}
- 				INIT_WORK(&dmub_hpd_wrk->handle_hpd_work, dm_handle_hpd_work);
- 				dmub_hpd_wrk->adev = adev;
- 				queue_work(adev->dm.delayed_hpd_wq, &dmub_hpd_wrk->handle_hpd_work);
- 			} else {
- 				dm->dmub_callback[notify.type](adev, &notify);
- 			}
- 		} while (notify.pending_notification);
- 	}
- }
- 
  static int dm_set_clockgating_state(struct amdgpu_ip_block *ip_block,
  		  enum amd_clockgating_state state)
  {
@@@ -1073,401 -332,6 +332,6 @@@ static int dm_set_powergating_state(str
  static int dm_early_init(struct amdgpu_ip_block *ip_block);
  
  /* Allocate memory for FBC compressed data  */
- static void amdgpu_dm_fbc_init(struct drm_connector *connector)
- {
- 	struct amdgpu_device *adev = drm_to_adev(connector->dev);
- 	struct dm_compressor_info *compressor = &adev->dm.compressor;
- 	struct amdgpu_dm_connector *aconn = to_amdgpu_dm_connector(connector);
- 	struct drm_display_mode *mode;
- 	unsigned long max_size = 0;
- 
- 	if (adev->dm.dc->fbc_compressor == NULL)
- 		return;
- 
- 	if (aconn->dc_link->connector_signal != SIGNAL_TYPE_EDP)
- 		return;
- 
- 	if (compressor->bo_ptr)
- 		return;
- 
- 
- 	list_for_each_entry(mode, &connector->modes, head) {
- 		if (max_size < (unsigned long) mode->htotal * mode->vtotal)
- 			max_size = (unsigned long) mode->htotal * mode->vtotal;
- 	}
- 
- 	if (max_size) {
- 		int r = amdgpu_bo_create_kernel(adev, max_size * 4, PAGE_SIZE,
- 			    AMDGPU_GEM_DOMAIN_GTT, &compressor->bo_ptr,
- 			    &compressor->gpu_addr, &compressor->cpu_addr);
- 
- 		if (r)
- 			drm_err(adev_to_drm(adev), "DM: Failed to initialize FBC\n");
- 		else {
- 			adev->dm.dc->ctx->fbc_gpu_addr = compressor->gpu_addr;
- 			drm_info(adev_to_drm(adev), "DM: FBC alloc %lu\n", max_size*4);
- 		}
- 
- 	}
- 
- }
- 
- static int amdgpu_dm_audio_component_get_eld(struct device *kdev, int port,
- 					  int pipe, bool *enabled,
- 					  unsigned char *buf, int max_bytes)
- {
- 	struct drm_device *dev = dev_get_drvdata(kdev);
- 	struct amdgpu_device *adev = drm_to_adev(dev);
- 	struct drm_connector *connector;
- 	struct drm_connector_list_iter conn_iter;
- 	struct amdgpu_dm_connector *aconnector;
- 	int ret = 0;
- 
- 	*enabled = false;
- 
- 	mutex_lock(&adev->dm.audio_lock);
- 
- 	drm_connector_list_iter_begin(dev, &conn_iter);
- 	drm_for_each_connector_iter(connector, &conn_iter) {
- 
- 		if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
- 			continue;
- 
- 		aconnector = to_amdgpu_dm_connector(connector);
- 		if (aconnector->audio_inst != port)
- 			continue;
- 
- 		*enabled = true;
- 		mutex_lock(&connector->eld_mutex);
- 		ret = drm_eld_size(connector->eld);
- 		memcpy(buf, connector->eld, min(max_bytes, ret));
- 		mutex_unlock(&connector->eld_mutex);
- 
- 		break;
- 	}
- 	drm_connector_list_iter_end(&conn_iter);
- 
- 	mutex_unlock(&adev->dm.audio_lock);
- 
- 	drm_dbg_kms(adev_to_drm(adev), "Get ELD : idx=%d ret=%d en=%d\n", port, ret, *enabled);
- 
- 	return ret;
- }
- 
- static const struct drm_audio_component_ops amdgpu_dm_audio_component_ops = {
- 	.get_eld = amdgpu_dm_audio_component_get_eld,
- };
- 
- static int amdgpu_dm_audio_component_bind(struct device *kdev,
- 				       struct device *hda_kdev, void *data)
- {
- 	struct drm_device *dev = dev_get_drvdata(kdev);
- 	struct amdgpu_device *adev = drm_to_adev(dev);
- 	struct drm_audio_component *acomp = data;
- 
- 	acomp->ops = &amdgpu_dm_audio_component_ops;
- 	acomp->dev = kdev;
- 	adev->dm.audio_component = acomp;
- 
- 	return 0;
- }
- 
- static void amdgpu_dm_audio_component_unbind(struct device *kdev,
- 					  struct device *hda_kdev, void *data)
- {
- 	struct amdgpu_device *adev = drm_to_adev(dev_get_drvdata(kdev));
- 	struct drm_audio_component *acomp = data;
- 
- 	acomp->ops = NULL;
- 	acomp->dev = NULL;
- 	adev->dm.audio_component = NULL;
- }
- 
- static const struct component_ops amdgpu_dm_audio_component_bind_ops = {
- 	.bind	= amdgpu_dm_audio_component_bind,
- 	.unbind	= amdgpu_dm_audio_component_unbind,
- };
- 
- static int amdgpu_dm_audio_init(struct amdgpu_device *adev)
- {
- 	int i, ret;
- 
- 	if (!amdgpu_audio)
- 		return 0;
- 
- 	adev->mode_info.audio.enabled = true;
- 
- 	adev->mode_info.audio.num_pins = adev->dm.dc->res_pool->audio_count;
- 
- 	for (i = 0; i < adev->mode_info.audio.num_pins; i++) {
- 		adev->mode_info.audio.pin[i].channels = -1;
- 		adev->mode_info.audio.pin[i].rate = -1;
- 		adev->mode_info.audio.pin[i].bits_per_sample = -1;
- 		adev->mode_info.audio.pin[i].status_bits = 0;
- 		adev->mode_info.audio.pin[i].category_code = 0;
- 		adev->mode_info.audio.pin[i].connected = false;
- 		adev->mode_info.audio.pin[i].id =
- 			adev->dm.dc->res_pool->audios[i]->inst;
- 		adev->mode_info.audio.pin[i].offset = 0;
- 	}
- 
- 	ret = component_add(adev->dev, &amdgpu_dm_audio_component_bind_ops);
- 	if (ret < 0)
- 		return ret;
- 
- 	adev->dm.audio_registered = true;
- 
- 	return 0;
- }
- 
- static void amdgpu_dm_audio_fini(struct amdgpu_device *adev)
- {
- 	if (!amdgpu_audio)
- 		return;
- 
- 	if (!adev->mode_info.audio.enabled)
- 		return;
- 
- 	if (adev->dm.audio_registered) {
- 		component_del(adev->dev, &amdgpu_dm_audio_component_bind_ops);
- 		adev->dm.audio_registered = false;
- 	}
- 
- 	/* TODO: Disable audio? */
- 
- 	adev->mode_info.audio.enabled = false;
- }
- 
- static  void amdgpu_dm_audio_eld_notify(struct amdgpu_device *adev, int pin)
- {
- 	struct drm_audio_component *acomp = adev->dm.audio_component;
- 
- 	if (acomp && acomp->audio_ops && acomp->audio_ops->pin_eld_notify) {
- 		drm_dbg_kms(adev_to_drm(adev), "Notify ELD: %d\n", pin);
- 
- 		acomp->audio_ops->pin_eld_notify(acomp->audio_ops->audio_ptr,
- 						 pin, -1);
- 	}
- }
- 
- static int dm_dmub_hw_init(struct amdgpu_device *adev)
- {
- 	const struct dmcub_firmware_header_v1_0 *hdr;
- 	struct dmub_srv *dmub_srv = adev->dm.dmub_srv;
- 	struct dmub_srv_fb_info *fb_info = adev->dm.dmub_fb_info;
- 	const struct firmware *dmub_fw = adev->dm.dmub_fw;
- 	struct dc *dc = adev->dm.dc;
- 	struct dmcu *dmcu = adev->dm.dc->res_pool->dmcu;
- 	struct abm *abm = adev->dm.dc->res_pool->abm;
- 	struct dc_context *ctx = adev->dm.dc->ctx;
- 	struct dmub_srv_hw_params hw_params;
- 	enum dmub_status status;
- 	const unsigned char *fw_inst_const, *fw_bss_data;
- 	u32 i, fw_inst_const_size, fw_bss_data_size;
- 	bool has_hw_support;
- 
- 	if (!dmub_srv)
- 		/* DMUB isn't supported on the ASIC. */
- 		return 0;
- 
- 	if (!fb_info) {
- 		drm_err(adev_to_drm(adev), "No framebuffer info for DMUB service.\n");
- 		return -EINVAL;
- 	}
- 
- 	if (!dmub_fw) {
- 		/* Firmware required for DMUB support. */
- 		drm_err(adev_to_drm(adev), "No firmware provided for DMUB.\n");
- 		return -EINVAL;
- 	}
- 
- 	/* initialize register offsets for ASICs with runtime initialization available */
- 	if (dmub_srv->hw_funcs.init_reg_offsets)
- 		dmub_srv->hw_funcs.init_reg_offsets(dmub_srv, ctx);
- 
- 	status = dmub_srv_has_hw_support(dmub_srv, &has_hw_support);
- 	if (status != DMUB_STATUS_OK) {
- 		drm_err(adev_to_drm(adev), "Error checking HW support for DMUB: %d\n", status);
- 		return -EINVAL;
- 	}
- 
- 	if (!has_hw_support) {
- 		drm_info(adev_to_drm(adev), "DMUB unsupported on ASIC\n");
- 		return 0;
- 	}
- 
- 	/* Reset DMCUB if it was previously running - before we overwrite its memory. */
- 	status = dmub_srv_hw_reset(dmub_srv);
- 	if (status != DMUB_STATUS_OK)
- 		drm_warn(adev_to_drm(adev), "Error resetting DMUB HW: %d\n", status);
- 
- 	hdr = (const struct dmcub_firmware_header_v1_0 *)dmub_fw->data;
- 
- 	fw_inst_const = dmub_fw->data +
- 			le32_to_cpu(hdr->header.ucode_array_offset_bytes) +
- 			PSP_HEADER_BYTES_256;
- 
- 	fw_bss_data = dmub_fw->data +
- 		      le32_to_cpu(hdr->header.ucode_array_offset_bytes) +
- 		      le32_to_cpu(hdr->inst_const_bytes);
- 
- 	/* Copy firmware and bios info into FB memory. */
- 	fw_inst_const_size = adev->dm.fw_inst_size;
- 
- 	fw_bss_data_size = le32_to_cpu(hdr->bss_data_bytes);
- 
- 	/* if adev->firmware.load_type == AMDGPU_FW_LOAD_PSP,
- 	 * amdgpu_ucode_init_single_fw will load dmub firmware
- 	 * fw_inst_const part to cw0; otherwise, the firmware back door load
- 	 * will be done by dm_dmub_hw_init
- 	 */
- 	if (adev->firmware.load_type != AMDGPU_FW_LOAD_PSP) {
- 		memcpy(fb_info->fb[DMUB_WINDOW_0_INST_CONST].cpu_addr, fw_inst_const,
- 				fw_inst_const_size);
- 	}
- 
- 	if (fw_bss_data_size)
- 		memcpy(fb_info->fb[DMUB_WINDOW_2_BSS_DATA].cpu_addr,
- 		       fw_bss_data, fw_bss_data_size);
- 
- 	/* Copy firmware bios info into FB memory. */
- 	memcpy(fb_info->fb[DMUB_WINDOW_3_VBIOS].cpu_addr, adev->bios,
- 	       adev->bios_size);
- 
- 	/* Reset regions that need to be reset. */
- 	memset(fb_info->fb[DMUB_WINDOW_4_MAILBOX].cpu_addr, 0,
- 	fb_info->fb[DMUB_WINDOW_4_MAILBOX].size);
- 
- 	memset(fb_info->fb[DMUB_WINDOW_5_TRACEBUFF].cpu_addr, 0,
- 	       fb_info->fb[DMUB_WINDOW_5_TRACEBUFF].size);
- 
- 	memset(fb_info->fb[DMUB_WINDOW_6_FW_STATE].cpu_addr, 0,
- 	       fb_info->fb[DMUB_WINDOW_6_FW_STATE].size);
- 
- 	memset(fb_info->fb[DMUB_WINDOW_SHARED_STATE].cpu_addr, 0,
- 	       fb_info->fb[DMUB_WINDOW_SHARED_STATE].size);
- 
- 	/* Initialize hardware. */
- 	memset(&hw_params, 0, sizeof(hw_params));
- 	hw_params.soc_fb_info.fb_base = adev->gmc.fb_start;
- 	hw_params.soc_fb_info.fb_offset = adev->vm_manager.vram_base_offset;
- 
- 	/* backdoor load firmware and trigger dmub running */
- 	if (adev->firmware.load_type != AMDGPU_FW_LOAD_PSP)
- 		hw_params.load_inst_const = true;
- 
- 	if (dmcu)
- 		hw_params.psp_version = dmcu->psp_version;
- 
- 	for (i = 0; i < fb_info->num_fb; ++i)
- 		hw_params.fb[i] = &fb_info->fb[i];
- 
- 	/* Enable usb4 dpia in the FW APU */
- 	if (dc->caps.is_apu &&
- 		dc->res_pool->usb4_dpia_count != 0 &&
- 		!dc->debug.dpia_debug.bits.disable_dpia) {
- 		hw_params.dpia_supported = true;
- 		hw_params.disable_dpia = dc->debug.dpia_debug.bits.disable_dpia;
- 		hw_params.dpia_hpd_int_enable_supported = false;
- 		hw_params.enable_non_transparent_setconfig = dc->config.consolidated_dpia_dp_lt;
- 		hw_params.disable_dpia_bw_allocation = !dc->config.usb4_bw_alloc_support;
- 	}
- 
- 	switch (amdgpu_ip_version(adev, DCE_HWIP, 0)) {
- 	case IP_VERSION(3, 5, 0):
- 	case IP_VERSION(3, 5, 1):
- 	case IP_VERSION(3, 6, 0):
- 	case IP_VERSION(4, 2, 0):
- 	case IP_VERSION(4, 2, 1):
- 		hw_params.ips_sequential_ono = adev->external_rev_id > 0x10;
- 		hw_params.lower_hbr3_phy_ssc = true;
- 		break;
- 	default:
- 		break;
- 	}
- 
- 	status = dmub_srv_hw_init(dmub_srv, &hw_params);
- 	if (status != DMUB_STATUS_OK) {
- 		drm_err(adev_to_drm(adev), "Error initializing DMUB HW: %d\n", status);
- 		return -EINVAL;
- 	}
- 
- 	/* Wait for firmware load to finish. */
- 	status = dmub_srv_wait_for_auto_load(dmub_srv, 100000);
- 	if (status != DMUB_STATUS_OK)
- 		drm_warn(adev_to_drm(adev), "Wait for DMUB auto-load failed: %d\n", status);
- 
- 	/* Init DMCU and ABM if available. */
- 	if (dmcu && abm) {
- 		dmcu->funcs->dmcu_init(dmcu);
- 		abm->dmcu_is_running = dmcu->funcs->is_dmcu_initialized(dmcu);
- 	}
- 
- 	if (!adev->dm.dc->ctx->dmub_srv)
- 		adev->dm.dc->ctx->dmub_srv = dc_dmub_srv_create(adev->dm.dc, dmub_srv);
- 	if (!adev->dm.dc->ctx->dmub_srv) {
- 		drm_err(adev_to_drm(adev), "Couldn't allocate DC DMUB server!\n");
- 		return -ENOMEM;
- 	}
- 
- 	drm_info(adev_to_drm(adev), "DMUB hardware initialized: version=0x%08X\n",
- 		 adev->dm.dmcub_fw_version);
- 
- 	/* Keeping sanity checks off if
- 	 * DCN31 >= 4.0.59.0
- 	 * DCN314 >= 8.0.16.0
- 	 * Otherwise, turn on sanity checks
- 	 */
- 	switch (amdgpu_ip_version(adev, DCE_HWIP, 0)) {
- 	case IP_VERSION(3, 1, 2):
- 	case IP_VERSION(3, 1, 3):
- 		if (adev->dm.dmcub_fw_version &&
- 			adev->dm.dmcub_fw_version >= DMUB_FW_VERSION(4, 0, 0) &&
- 			adev->dm.dmcub_fw_version < DMUB_FW_VERSION(4, 0, 59))
- 				adev->dm.dc->debug.sanity_checks = true;
- 		break;
- 	case IP_VERSION(3, 1, 4):
- 		if (adev->dm.dmcub_fw_version &&
- 			adev->dm.dmcub_fw_version >= DMUB_FW_VERSION(4, 0, 0) &&
- 			adev->dm.dmcub_fw_version < DMUB_FW_VERSION(8, 0, 16))
- 				adev->dm.dc->debug.sanity_checks = true;
- 		break;
- 	default:
- 		break;
- 	}
- 
- 	return 0;
- }
- 
- static void dm_dmub_hw_resume(struct amdgpu_device *adev)
- {
- 	struct dmub_srv *dmub_srv = adev->dm.dmub_srv;
- 	enum dmub_status status;
- 	bool init;
- 	int r;
- 
- 	if (!dmub_srv) {
- 		/* DMUB isn't supported on the ASIC. */
- 		return;
- 	}
- 
- 	status = dmub_srv_is_hw_init(dmub_srv, &init);
- 	if (status != DMUB_STATUS_OK)
- 		drm_warn(adev_to_drm(adev), "DMUB hardware init check failed: %d\n", status);
- 
- 	if (status == DMUB_STATUS_OK && init) {
- 		/* Wait for firmware load to finish. */
- 		status = dmub_srv_wait_for_auto_load(dmub_srv, 100000);
- 		if (status != DMUB_STATUS_OK)
- 			drm_warn(adev_to_drm(adev), "Wait for DMUB auto-load failed: %d\n", status);
- 	} else {
- 		/* Perform the full hardware initialization. */
- 		r = dm_dmub_hw_init(adev);
- 		if (r)
- 			drm_err(adev_to_drm(adev), "DMUB interface failed to initialize: status=%d\n", r);
- 	}
- }
- 
  static void mmhub_read_system_context(struct amdgpu_device *adev, struct dc_phy_addr_space_config *pa_config)
  {
  	u64 pt_base;
@@@ -1545,151 -409,6 +409,6 @@@
  
  }
  
- static void force_connector_state(
- 	struct amdgpu_dm_connector *aconnector,
- 	enum drm_connector_force force_state)
- {
- 	struct drm_connector *connector = &aconnector->base;
- 
- 	mutex_lock(&connector->dev->mode_config.mutex);
- 	aconnector->base.force = force_state;
- 	mutex_unlock(&connector->dev->mode_config.mutex);
- 
- 	mutex_lock(&aconnector->hpd_lock);
- 	drm_kms_helper_connector_hotplug_event(connector);
- 	mutex_unlock(&aconnector->hpd_lock);
- }
- 
- static void dm_handle_hpd_rx_offload_work(struct work_struct *work)
- {
- 	struct hpd_rx_irq_offload_work *offload_work;
- 	struct amdgpu_dm_connector *aconnector;
- 	struct dc_link *dc_link;
- 	struct amdgpu_device *adev;
- 	enum dc_connection_type new_connection_type = dc_connection_none;
- 	unsigned long flags;
- 	union test_response test_response;
- 
- 	memset(&test_response, 0, sizeof(test_response));
- 
- 	offload_work = container_of(work, struct hpd_rx_irq_offload_work, work);
- 	aconnector = offload_work->offload_wq->aconnector;
- 	adev = offload_work->adev;
- 
- 	if (!aconnector) {
- 		drm_err(adev_to_drm(adev), "Can't retrieve aconnector in hpd_rx_irq_offload_work");
- 		goto skip;
- 	}
- 
- 	dc_link = aconnector->dc_link;
- 
- 	mutex_lock(&aconnector->hpd_lock);
- 	if (!dc_link_detect_connection_type(dc_link, &new_connection_type))
- 		drm_err(adev_to_drm(adev), "KMS: Failed to detect connector\n");
- 	mutex_unlock(&aconnector->hpd_lock);
- 
- 	if (new_connection_type == dc_connection_none)
- 		goto skip;
- 
- 	if (amdgpu_in_reset(adev))
- 		goto skip;
- 
- 	if (offload_work->data.bytes.device_service_irq.bits.UP_REQ_MSG_RDY ||
- 		offload_work->data.bytes.device_service_irq.bits.DOWN_REP_MSG_RDY) {
- 		dm_handle_mst_sideband_msg_ready_event(&aconnector->mst_mgr, DOWN_OR_UP_MSG_RDY_EVENT);
- 		spin_lock_irqsave(&offload_work->offload_wq->offload_lock, flags);
- 		offload_work->offload_wq->is_handling_mst_msg_rdy_event = false;
- 		spin_unlock_irqrestore(&offload_work->offload_wq->offload_lock, flags);
- 		goto skip;
- 	}
- 
- 	mutex_lock(&adev->dm.dc_lock);
- 	if (offload_work->data.bytes.device_service_irq.bits.AUTOMATED_TEST) {
- 		dc_link_dp_handle_automated_test(dc_link);
- 
- 		if (aconnector->timing_changed) {
- 			/* force connector disconnect and reconnect */
- 			force_connector_state(aconnector, DRM_FORCE_OFF);
- 			msleep(100);
- 			force_connector_state(aconnector, DRM_FORCE_UNSPECIFIED);
- 		}
- 
- 		test_response.bits.ACK = 1;
- 
- 		core_link_write_dpcd(
- 		dc_link,
- 		DP_TEST_RESPONSE,
- 		&test_response.raw,
- 		sizeof(test_response));
- 	} else if ((dc_link->connector_signal != SIGNAL_TYPE_EDP) &&
- 			dc_link_check_link_loss_status(dc_link, &offload_work->data) &&
- 			dc_link_dp_allow_hpd_rx_irq(dc_link)) {
- 		/* offload_work->data is from handle_hpd_rx_irq->
- 		 * schedule_hpd_rx_offload_work.this is defer handle
- 		 * for hpd short pulse. upon here, link status may be
- 		 * changed, need get latest link status from dpcd
- 		 * registers. if link status is good, skip run link
- 		 * training again.
- 		 */
- 		union hpd_irq_data irq_data;
- 
- 		memset(&irq_data, 0, sizeof(irq_data));
- 
- 		/* before dc_link_dp_handle_link_loss, allow new link lost handle
- 		 * request be added to work queue if link lost at end of dc_link_
- 		 * dp_handle_link_loss
- 		 */
- 		spin_lock_irqsave(&offload_work->offload_wq->offload_lock, flags);
- 		offload_work->offload_wq->is_handling_link_loss = false;
- 		spin_unlock_irqrestore(&offload_work->offload_wq->offload_lock, flags);
- 
- 		if ((dc_link_dp_read_hpd_rx_irq_data(dc_link, &irq_data) == DC_OK) &&
- 			dc_link_check_link_loss_status(dc_link, &irq_data))
- 			dc_link_dp_handle_link_loss(dc_link);
- 	}
- 	mutex_unlock(&adev->dm.dc_lock);
- 
- skip:
- 	kfree(offload_work);
- 
- }
- 
- static struct hpd_rx_irq_offload_work_queue *hpd_rx_irq_create_workqueue(struct amdgpu_device *adev)
- {
- 	struct dc *dc = adev->dm.dc;
- 	int max_caps = dc->caps.max_links;
- 	int i = 0;
- 	struct hpd_rx_irq_offload_work_queue *hpd_rx_offload_wq = NULL;
- 
- 	hpd_rx_offload_wq = kzalloc_objs(*hpd_rx_offload_wq, max_caps);
- 
- 	if (!hpd_rx_offload_wq)
- 		return NULL;
- 
- 
- 	for (i = 0; i < max_caps; i++) {
- 		hpd_rx_offload_wq[i].wq =
- 				    create_singlethread_workqueue("amdgpu_dm_hpd_rx_offload_wq");
- 
- 		if (hpd_rx_offload_wq[i].wq == NULL) {
- 			drm_err(adev_to_drm(adev), "create amdgpu_dm_hpd_rx_offload_wq fail!");
- 			goto out_err;
- 		}
- 
- 		spin_lock_init(&hpd_rx_offload_wq[i].offload_lock);
- 	}
- 
- 	return hpd_rx_offload_wq;
- 
- out_err:
- 	for (i = 0; i < max_caps; i++) {
- 		if (hpd_rx_offload_wq[i].wq)
- 			destroy_workqueue(hpd_rx_offload_wq[i].wq);
- 	}
- 	kfree(hpd_rx_offload_wq);
- 	return NULL;
- }
- 
  struct amdgpu_stutter_quirk {
  	u16 chip_vendor;
  	u16 chip_device;
@@@ -1775,119 -494,6 +494,6 @@@ dm_free_gpu_mem
  
  }
  
- static enum dmub_status
- dm_dmub_send_vbios_gpint_command(struct amdgpu_device *adev,
- 				 enum dmub_gpint_command command_code,
- 				 uint16_t param,
- 				 uint32_t timeout_us)
- {
- 	union dmub_gpint_data_register reg, test;
- 	uint32_t i;
- 
- 	/* Assume that VBIOS DMUB is ready to take commands */
- 
- 	reg.bits.status = 1;
- 	reg.bits.command_code = command_code;
- 	reg.bits.param = param;
- 
- 	cgs_write_register(adev->dm.cgs_device, 0x34c0 + 0x01f8, reg.all);
- 
- 	for (i = 0; i < timeout_us; ++i) {
- 		udelay(1);
- 
- 		/* Check if our GPINT got acked */
- 		reg.bits.status = 0;
- 		test = (union dmub_gpint_data_register)
- 			cgs_read_register(adev->dm.cgs_device, 0x34c0 + 0x01f8);
- 
- 		if (test.all == reg.all)
- 			return DMUB_STATUS_OK;
- 	}
- 
- 	return DMUB_STATUS_TIMEOUT;
- }
- 
- static void *dm_dmub_get_vbios_bounding_box(struct amdgpu_device *adev)
- {
- 	void *bb;
- 	long long addr;
- 	unsigned int bb_size;
- 	int i = 0;
- 	uint16_t chunk;
- 	enum dmub_gpint_command send_addrs[] = {
- 		DMUB_GPINT__SET_BB_ADDR_WORD0,
- 		DMUB_GPINT__SET_BB_ADDR_WORD1,
- 		DMUB_GPINT__SET_BB_ADDR_WORD2,
- 		DMUB_GPINT__SET_BB_ADDR_WORD3,
- 	};
- 	enum dmub_status ret;
- 
- 	switch (amdgpu_ip_version(adev, DCE_HWIP, 0)) {
- 	case IP_VERSION(4, 0, 1):
- 		bb_size = sizeof(struct dml2_soc_bb);
- 		break;
- 	case IP_VERSION(4, 2, 0):
- 	case IP_VERSION(4, 2, 1):
- 		bb_size = sizeof(struct dml2_soc_bb);
- 		break;
- 	default:
- 		return NULL;
- 	}
- 
- 	bb =  dm_allocate_gpu_mem(adev,
- 				  DC_MEM_ALLOC_TYPE_GART,
- 				  bb_size,
- 				  &addr);
- 	if (!bb)
- 		return NULL;
- 
- 	for (i = 0; i < 4; i++) {
- 		/* Extract 16-bit chunk */
- 		chunk = ((uint64_t) addr >> (i * 16)) & 0xFFFF;
- 		/* Send the chunk */
- 		ret = dm_dmub_send_vbios_gpint_command(adev, send_addrs[i], chunk, 30000);
- 		if (ret != DMUB_STATUS_OK)
- 			goto free_bb;
- 	}
- 
- 	/* Now ask DMUB to copy the bb */
- 	ret = dm_dmub_send_vbios_gpint_command(adev, DMUB_GPINT__BB_COPY, 1, 200000);
- 	if (ret != DMUB_STATUS_OK)
- 		goto free_bb;
- 
- 	return bb;
- 
- free_bb:
- 	dm_free_gpu_mem(adev, DC_MEM_ALLOC_TYPE_GART, (void *) bb);
- 	return NULL;
- 
- }
- 
- static enum dmub_ips_disable_type dm_get_default_ips_mode(
- 	struct amdgpu_device *adev)
- {
- 	enum dmub_ips_disable_type ret = DMUB_IPS_ENABLE;
- 
- 	switch (amdgpu_ip_version(adev, DCE_HWIP, 0)) {
- 	case IP_VERSION(3, 5, 0):
- 	case IP_VERSION(3, 6, 0):
- 	case IP_VERSION(3, 5, 1):
- 		ret =  DMUB_IPS_RCG_IN_ACTIVE_IPS2_IN_OFF;
- 		break;
- 	case IP_VERSION(4, 2, 0):
- 	case IP_VERSION(4, 2, 1):
- 		ret =  DMUB_IPS_ENABLE;
- 		break;
- 	default:
- 		/* ASICs older than DCN35 do not have IPSs */
- 		if (amdgpu_ip_version(adev, DCE_HWIP, 0) < IP_VERSION(3, 5, 0))
- 			ret = DMUB_IPS_DISABLE_ALL;
- 		break;
- 	}
- 
- 	return ret;
- }
- 
  static int amdgpu_dm_init_power_module(struct amdgpu_display_manager *dm)
  {
  	struct mod_power_init_params init_data[MAX_NUM_EDP];
@@@ -1952,40 -558,6 +558,6 @@@
  	return 0;
  }
  
- static void hdmi_frl_status_polling_work(struct work_struct *work)
- {
- 	struct amdgpu_display_manager *dm =
- 		container_of(to_delayed_work(work), struct amdgpu_display_manager,
- 				hdmi_frl_status_polling_work);
- 	struct dc *dc = dm->dc;
- 	struct dc_link *dc_link;
- 	bool link_update = false;
- 
- 	for (int i = 0; i < MAX_LINKS; i++) {
- 		dc_link = dc->links[i];
- 
- 		if (!dc_link || !dc_link->local_sink)
- 			continue;
- 
- 		if (!dc_is_hdmi_signal(dc_link->connector_signal))
- 			continue;
- 
- 		if (dc_link->connector_signal != SIGNAL_TYPE_HDMI_FRL)
- 			continue;
- 
- 		link_update = dc_link_frl_poll_status_flag(dc_link);
- 		if (link_update) {
- 			mutex_lock(&dm->dc_lock);
- 			dc_link_detect(dc_link, DETECT_REASON_RETRAIN);
- 			mutex_unlock(&dm->dc_lock);
- 		}
- 	}
- 
- 	queue_delayed_work(dm->hdmi_frl_status_polling_wq,
- 			   &dm->hdmi_frl_status_polling_work,
- 			   msecs_to_jiffies(dm->hdmi_frl_status_polling_delay_ms));
- }
- 
  static int amdgpu_dm_init(struct amdgpu_device *adev)
  {
  	struct dc_init_data init_data;
@@@ -2212,7 -784,7 +784,7 @@@
  
  	dc_hardware_init(adev->dm.dc);
  
- 	adev->dm.hpd_rx_offload_wq = hpd_rx_irq_create_workqueue(adev);
+ 	adev->dm.hpd_rx_offload_wq = amdgpu_dm_hpd_rx_irq_create_workqueue(adev);
  	if (!adev->dm.hpd_rx_offload_wq) {
  		drm_err(adev_to_drm(adev), "failed to create hpd rx offload workqueue.\n");
  		goto error;
@@@ -2265,8 -837,6 +837,6 @@@
  			create_singlethread_workqueue("hdmi_frl_status_polling_workqueue");
  		if (!adev->dm.hdmi_frl_status_polling_wq)
  			drm_err(adev_to_drm(adev), "failed to initialize hdmi_frl_status_polling_workqueue\n");
- 		adev->dm.hdmi_frl_status_polling_delay_ms = 200;
- 		INIT_DELAYED_WORK(&adev->dm.hdmi_frl_status_polling_work, hdmi_frl_status_polling_work);
  	}
  	if (dc_is_dmub_outbox_supported(adev->dm.dc)) {
  		init_completion(&adev->dm.dmub_aux_transfer_done);
@@@ -2283,8 -853,8 +853,8 @@@
  		}
  
  		amdgpu_dm_outbox_init(adev);
- 		if (!register_dmub_notify_callback(adev, DMUB_NOTIFICATION_AUX_REPLY,
- 			dmub_aux_setconfig_callback, false)) {
+ 		if (!dm_register_dmub_notify_callback(adev, DMUB_NOTIFICATION_AUX_REPLY,
+ 			dm_dmub_aux_setconfig_callback, false)) {
  			drm_err(adev_to_drm(adev), "fail to register dmub aux callback");
  			goto error;
  		}
@@@ -2292,16 -862,17 +862,17 @@@
  		for (size_t i = 0; i < ARRAY_SIZE(adev->dm.fused_io); i++)
  			init_completion(&adev->dm.fused_io[i].replied);
  
- 		if (!register_dmub_notify_callback(adev, DMUB_NOTIFICATION_FUSED_IO,
- 			dmub_aux_fused_io_callback, false)) {
+ 		if (!dm_register_dmub_notify_callback(adev, DMUB_NOTIFICATION_FUSED_IO,
+ 			dm_dmub_aux_fused_io_callback, false)) {
  			drm_err(adev_to_drm(adev), "fail to register dmub fused io callback");
  			goto error;
  		}
  		/* Enable outbox notification only after IRQ handlers are registered and DMUB is alive.
  		 * It is expected that DMUB will resend any pending notifications at this point. Note
- 		 * that hpd and hpd_irq handler registration are deferred to register_hpd_handlers() to
- 		 * align legacy interface initialization sequence. Connection status will be proactivly
- 		 * detected once in the amdgpu_dm_initialize_drm_device.
+ 		 * that hpd and hpd_irq handler registration are deferred to
+ 		 * amdgpu_dm_register_hpd_handlers() to align legacy interface initialization
+ 		 * sequence. Connection status will be proactivly detected once in the
+ 		 * amdgpu_dm_initialize_drm_device.
  		 */
  		dc_enable_dmub_outbox(adev->dm.dc);
  
@@@ -2581,224 -1152,6 +1152,6 @@@ static int load_dmcu_fw(struct amdgpu_d
  	return 0;
  }
  
- static uint32_t amdgpu_dm_dmub_reg_read(void *ctx, uint32_t address)
- {
- 	struct amdgpu_device *adev = ctx;
- 
- 	return dm_read_reg(adev->dm.dc->ctx, address);
- }
- 
- static void amdgpu_dm_dmub_reg_write(void *ctx, uint32_t address,
- 				     uint32_t value)
- {
- 	struct amdgpu_device *adev = ctx;
- 
- 	return dm_write_reg(adev->dm.dc->ctx, address, value);
- }
- 
- static int dm_dmub_sw_init(struct amdgpu_device *adev)
- {
- 	struct dmub_srv_create_params create_params;
- 	struct dmub_srv_fw_meta_info_params fw_meta_info_params;
- 	struct dmub_srv_region_params region_params;
- 	struct dmub_srv_region_info region_info;
- 	struct dmub_srv_memory_params memory_params;
- 	struct dmub_fw_meta_info fw_info;
- 	struct dmub_srv_fb_info *fb_info;
- 	struct dmub_srv *dmub_srv;
- 	const struct dmcub_firmware_header_v1_0 *hdr;
- 	enum dmub_asic dmub_asic;
- 	enum dmub_status status;
- 	static enum dmub_window_memory_type window_memory_type[DMUB_WINDOW_TOTAL] = {
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_0_INST_CONST
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_1_STACK
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_2_BSS_DATA
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_3_VBIOS
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_4_MAILBOX
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_5_TRACEBUFF
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_6_FW_STATE
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_7_SCRATCH_MEM
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_IB_MEM
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_SHARED_STATE
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_LSDMA_BUFFER
- 		DMUB_WINDOW_MEMORY_TYPE_FB,		//DMUB_WINDOW_CURSOR_OFFLOAD
- 	};
- 	int r;
- 
- 	switch (amdgpu_ip_version(adev, DCE_HWIP, 0)) {
- 	case IP_VERSION(2, 1, 0):
- 		dmub_asic = DMUB_ASIC_DCN21;
- 		break;
- 	case IP_VERSION(3, 0, 0):
- 		dmub_asic = DMUB_ASIC_DCN30;
- 		break;
- 	case IP_VERSION(3, 0, 1):
- 		dmub_asic = DMUB_ASIC_DCN301;
- 		break;
- 	case IP_VERSION(3, 0, 2):
- 		dmub_asic = DMUB_ASIC_DCN302;
- 		break;
- 	case IP_VERSION(3, 0, 3):
- 		dmub_asic = DMUB_ASIC_DCN303;
- 		break;
- 	case IP_VERSION(3, 1, 2):
- 	case IP_VERSION(3, 1, 3):
- 		dmub_asic = (adev->external_rev_id == YELLOW_CARP_B0) ? DMUB_ASIC_DCN31B : DMUB_ASIC_DCN31;
- 		break;
- 	case IP_VERSION(3, 1, 4):
- 		dmub_asic = DMUB_ASIC_DCN314;
- 		break;
- 	case IP_VERSION(3, 1, 5):
- 		dmub_asic = DMUB_ASIC_DCN315;
- 		break;
- 	case IP_VERSION(3, 1, 6):
- 		dmub_asic = DMUB_ASIC_DCN316;
- 		break;
- 	case IP_VERSION(3, 2, 0):
- 		dmub_asic = DMUB_ASIC_DCN32;
- 		break;
- 	case IP_VERSION(3, 2, 1):
- 		dmub_asic = DMUB_ASIC_DCN321;
- 		break;
- 	case IP_VERSION(3, 5, 0):
- 	case IP_VERSION(3, 5, 1):
- 		dmub_asic = DMUB_ASIC_DCN35;
- 		break;
- 	case IP_VERSION(3, 6, 0):
- 		dmub_asic = DMUB_ASIC_DCN36;
- 		break;
- 	case IP_VERSION(4, 0, 1):
- 		dmub_asic = DMUB_ASIC_DCN401;
- 		break;
- 	case IP_VERSION(4, 2, 0):
- 		dmub_asic = DMUB_ASIC_DCN42;
- 		break;
- 	case IP_VERSION(4, 2, 1):
- 		dmub_asic = DMUB_ASIC_DCN42B;
- 		break;
- 	default:
- 		/* ASIC doesn't support DMUB. */
- 		return 0;
- 	}
- 
- 	hdr = (const struct dmcub_firmware_header_v1_0 *)adev->dm.dmub_fw->data;
- 	adev->dm.dmcub_fw_version = le32_to_cpu(hdr->header.ucode_version);
- 
- 	if (adev->firmware.load_type == AMDGPU_FW_LOAD_PSP) {
- 		adev->firmware.ucode[AMDGPU_UCODE_ID_DMCUB].ucode_id =
- 			AMDGPU_UCODE_ID_DMCUB;
- 		adev->firmware.ucode[AMDGPU_UCODE_ID_DMCUB].fw =
- 			adev->dm.dmub_fw;
- 		adev->firmware.fw_size +=
- 			ALIGN(le32_to_cpu(hdr->inst_const_bytes), PAGE_SIZE);
- 
- 		drm_info(adev_to_drm(adev), "Loading DMUB firmware via PSP: version=0x%08X\n",
- 			 adev->dm.dmcub_fw_version);
- 	}
- 
- 
- 	adev->dm.dmub_srv = kzalloc_obj(*adev->dm.dmub_srv);
- 	dmub_srv = adev->dm.dmub_srv;
- 
- 	if (!dmub_srv) {
- 		drm_err(adev_to_drm(adev), "Failed to allocate DMUB service!\n");
- 		return -ENOMEM;
- 	}
- 
- 	memset(&create_params, 0, sizeof(create_params));
- 	create_params.user_ctx = adev;
- 	create_params.funcs.reg_read = amdgpu_dm_dmub_reg_read;
- 	create_params.funcs.reg_write = amdgpu_dm_dmub_reg_write;
- 	create_params.asic = dmub_asic;
- 
- 	/* Create the DMUB service. */
- 	status = dmub_srv_create(dmub_srv, &create_params);
- 	if (status != DMUB_STATUS_OK) {
- 		drm_err(adev_to_drm(adev), "Error creating DMUB service: %d\n", status);
- 		return -EINVAL;
- 	}
- 
- 	/* Extract the FW meta info. */
- 	memset(&fw_meta_info_params, 0, sizeof(fw_meta_info_params));
- 
- 	fw_meta_info_params.inst_const_size = le32_to_cpu(hdr->inst_const_bytes) -
- 					      PSP_HEADER_BYTES_256;
- 	fw_meta_info_params.bss_data_size = le32_to_cpu(hdr->bss_data_bytes);
- 	fw_meta_info_params.fw_inst_const = adev->dm.dmub_fw->data +
- 					    le32_to_cpu(hdr->header.ucode_array_offset_bytes) +
- 					    PSP_HEADER_BYTES_256;
- 	fw_meta_info_params.fw_bss_data = fw_meta_info_params.bss_data_size ? adev->dm.dmub_fw->data +
- 					  le32_to_cpu(hdr->header.ucode_array_offset_bytes) +
- 					  le32_to_cpu(hdr->inst_const_bytes) : NULL;
- 	fw_meta_info_params.custom_psp_footer_size = 0;
- 
- 	status = dmub_srv_get_fw_meta_info_from_raw_fw(&fw_meta_info_params, &fw_info);
- 	if (status != DMUB_STATUS_OK) {
- 		/* Skip returning early, just log the error. */
- 		drm_err(adev_to_drm(adev), "Error getting DMUB FW meta info: %d\n", status);
- 		// return -EINVAL;
- 	}
- 
- 	/* Calculate the size of all the regions for the DMUB service. */
- 	memset(&region_params, 0, sizeof(region_params));
- 
- 	region_params.inst_const_size = fw_meta_info_params.inst_const_size;
- 	region_params.bss_data_size = fw_meta_info_params.bss_data_size;
- 	region_params.vbios_size = adev->bios_size;
- 	region_params.fw_bss_data = fw_meta_info_params.fw_bss_data;
- 	region_params.fw_inst_const = fw_meta_info_params.fw_inst_const;
- 	region_params.window_memory_type = window_memory_type;
- 	region_params.fw_info = (status == DMUB_STATUS_OK) ? &fw_info : NULL;
- 
- 	status = dmub_srv_calc_region_info(dmub_srv, &region_params,
- 					   &region_info);
- 
- 	if (status != DMUB_STATUS_OK) {
- 		drm_err(adev_to_drm(adev), "Error calculating DMUB region info: %d\n", status);
- 		return -EINVAL;
- 	}
- 
- 	/*
- 	 * Allocate a framebuffer based on the total size of all the regions.
- 	 * TODO: Move this into GART.
- 	 */
- 	r = amdgpu_bo_create_kernel(adev, region_info.fb_size, PAGE_SIZE,
- 				    AMDGPU_GEM_DOMAIN_VRAM |
- 				    AMDGPU_GEM_DOMAIN_GTT,
- 				    &adev->dm.dmub_bo,
- 				    &adev->dm.dmub_bo_gpu_addr,
- 				    &adev->dm.dmub_bo_cpu_addr);
- 	if (r)
- 		return r;
- 
- 	/* Rebase the regions on the framebuffer address. */
- 	memset(&memory_params, 0, sizeof(memory_params));
- 	memory_params.cpu_fb_addr = adev->dm.dmub_bo_cpu_addr;
- 	memory_params.gpu_fb_addr = adev->dm.dmub_bo_gpu_addr;
- 	memory_params.region_info = &region_info;
- 	memory_params.window_memory_type = window_memory_type;
- 
- 	adev->dm.dmub_fb_info = kzalloc_obj(*adev->dm.dmub_fb_info);
- 	fb_info = adev->dm.dmub_fb_info;
- 
- 	if (!fb_info) {
- 		drm_err(adev_to_drm(adev),
- 			"Failed to allocate framebuffer info for DMUB service!\n");
- 		return -ENOMEM;
- 	}
- 
- 	status = dmub_srv_calc_mem_info(dmub_srv, &memory_params, fb_info);
- 	if (status != DMUB_STATUS_OK) {
- 		drm_err(adev_to_drm(adev), "Error calculating DMUB FB info: %d\n", status);
- 		return -EINVAL;
- 	}
- 
- 	adev->dm.bb_from_dmub = dm_dmub_get_vbios_bounding_box(adev);
- 	adev->dm.fw_inst_size = fw_meta_info_params.inst_const_size;
- 
- 	return 0;
- }
- 
  static int dm_sw_init(struct amdgpu_ip_block *ip_block)
  {
  	struct amdgpu_device *adev = ip_block->adev;
@@@ -2852,41 -1205,6 +1205,6 @@@ static int dm_sw_fini(struct amdgpu_ip_
  	return 0;
  }
  
- static int detect_mst_link_for_all_connectors(struct drm_device *dev)
- {
- 	struct amdgpu_dm_connector *aconnector;
- 	struct drm_connector *connector;
- 	struct drm_connector_list_iter iter;
- 	int ret = 0;
- 
- 	drm_connector_list_iter_begin(dev, &iter);
- 	drm_for_each_connector_iter(connector, &iter) {
- 
- 		if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
- 			continue;
- 
- 		aconnector = to_amdgpu_dm_connector(connector);
- 		if (aconnector->dc_link->type == dc_connection_mst_branch &&
- 		    aconnector->mst_mgr.aux) {
- 			drm_dbg_kms(dev, "DM_MST: starting TM on aconnector: %p [id: %d]\n",
- 					 aconnector,
- 					 aconnector->base.base.id);
- 
- 			ret = drm_dp_mst_topology_mgr_set_mst(&aconnector->mst_mgr, true);
- 			if (ret < 0) {
- 				drm_err(dev, "DM_MST: Failed to start MST\n");
- 				aconnector->dc_link->type =
- 					dc_connection_single;
- 				ret = dm_helpers_dp_mst_stop_top_mgr(aconnector->dc_link->ctx,
- 								     aconnector->dc_link);
- 				break;
- 			}
- 		}
- 	}
- 	drm_connector_list_iter_end(&iter);
- 
- 	return ret;
- }
  
  static void amdgpu_dm_boot_time_crc_init(struct amdgpu_device *adev)
  {
@@@ -2984,7 -1302,7 +1302,7 @@@ static int dm_late_init(struct amdgpu_i
  		}
  	}
  
- 	return detect_mst_link_for_all_connectors(adev_to_drm(adev));
+ 	return amdgpu_dm_detect_mst_link_for_all_connectors(adev_to_drm(adev));
  }
  
  static void resume_mst_branch_status(struct drm_dp_mst_topology_mgr *mgr)
@@@ -3038,48 -1356,6 +1356,6 @@@ out_fail
  	mutex_unlock(&mgr->lock);
  }
  
- void hdmi_cec_unset_edid(struct amdgpu_dm_connector *aconnector)
- {
- 	struct cec_notifier *n = aconnector->notifier;
- 
- 	if (!n)
- 		return;
- 
- 	cec_notifier_phys_addr_invalidate(n);
- }
- 
- void hdmi_cec_set_edid(struct amdgpu_dm_connector *aconnector)
- {
- 	struct drm_connector *connector = &aconnector->base;
- 	struct cec_notifier *n = aconnector->notifier;
- 
- 	if (!n)
- 		return;
- 
- 	cec_notifier_set_phys_addr(n,
- 				   connector->display_info.source_physical_address);
- }
- 
- static void s3_handle_hdmi_cec(struct drm_device *ddev, bool suspend)
- {
- 	struct amdgpu_dm_connector *aconnector;
- 	struct drm_connector *connector;
- 	struct drm_connector_list_iter conn_iter;
- 
- 	drm_connector_list_iter_begin(ddev, &conn_iter);
- 	drm_for_each_connector_iter(connector, &conn_iter) {
- 		if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
- 			continue;
- 
- 		aconnector = to_amdgpu_dm_connector(connector);
- 		if (suspend)
- 			hdmi_cec_unset_edid(aconnector);
- 		else
- 			hdmi_cec_set_edid(aconnector);
- 	}
- 	drm_connector_list_iter_end(&conn_iter);
- }
- 
  static void s3_handle_mst(struct drm_device *dev, bool suspend)
  {
  	struct amdgpu_dm_connector *aconnector;
@@@ -3182,7 -1458,7 +1458,7 @@@ static int dm_oem_i2c_hw_init(struct am
  
  	oem_ddc_service = dc_get_oem_i2c_device(adev->dm.dc);
  	if (oem_ddc_service) {
- 		oem_i2c = create_i2c(oem_ddc_service, true);
+ 		oem_i2c = amdgpu_dm_create_i2c(oem_ddc_service, true);
  		if (!oem_i2c) {
  			drm_info(adev_to_drm(adev), "Failed to create oem i2c adapter data\n");
  			return -ENOMEM;
@@@ -3267,7 -1543,7 +1543,7 @@@ static void dm_gpureset_toggle_interrup
  	int i = 0;
  
  	for (i = 0; i < state->stream_count; i++) {
- 		acrtc = get_crtc_by_otg_inst(
+ 		acrtc = amdgpu_dm_get_crtc_by_otg_inst(
  				adev, state->stream_status[i].primary_otg_inst);
  
  		if (acrtc && state->stream_status[i].plane_count != 0) {
@@@ -3344,16 -1620,6 +1620,6 @@@ static enum dc_status amdgpu_dm_commit_
  	return dc_commit_streams(dc, &params);
  }
  
- static void hpd_rx_irq_work_suspend(struct amdgpu_display_manager *dm)
- {
- 	int i;
- 
- 	if (dm->hpd_rx_offload_wq) {
- 		for (i = 0; i < dm->dc->caps.max_links; i++)
- 			flush_workqueue(dm->hpd_rx_offload_wq[i].wq);
- 	}
- }
- 
  static int dm_cache_state(struct amdgpu_device *adev)
  {
  	int r;
@@@ -3449,7 -1715,7 +1715,7 @@@ static int dm_suspend(struct amdgpu_ip_
  
  		amdgpu_dm_irq_suspend(adev);
  
- 		hpd_rx_irq_work_suspend(dm);
+ 		amdgpu_dm_hpd_rx_irq_work_suspend(dm);
  
  		return 0;
  	}
@@@ -3461,7 -1727,7 +1727,7 @@@
  			return r;
  	}
  
- 	s3_handle_hdmi_cec(adev_to_drm(adev), true);
+ 	amdgpu_dm_s3_handle_hdmi_cec(adev_to_drm(adev), true);
  
  	s3_handle_mst(adev_to_drm(adev), true);
  
@@@ -3475,7 -1741,7 +1741,7 @@@
  	scoped_guard(mutex, &dm->dc_lock)
  		amdgpu_dm_ism_force_full_power(dm);
  
- 	hpd_rx_irq_work_suspend(dm);
+ 	amdgpu_dm_hpd_rx_irq_work_suspend(dm);
  
  	dc_set_power_state(dm->dc, DC_ACPI_CM_POWER_STATE_D3);
  
@@@ -3487,26 -1753,7 +1753,7 @@@
  	return 0;
  }
  
- struct drm_connector *
- amdgpu_dm_find_first_crtc_matching_connector(struct drm_atomic_commit *state,
- 					     struct drm_crtc *crtc)
- {
- 	u32 i;
- 	struct drm_connector_state *new_con_state;
- 	struct drm_connector *connector;
- 	struct drm_crtc *crtc_from_state;
- 
- 	for_each_new_connector_in_state(state, connector, new_con_state, i) {
- 		crtc_from_state = new_con_state->crtc;
- 
- 		if (crtc_from_state == crtc)
- 			return connector;
- 	}
- 
- 	return NULL;
- }
- 
- static void emulated_link_detect(struct dc_link *link)
+ void amdgpu_dm_emulated_link_detect(struct dc_link *link)
  {
  	struct dc_sink_init_data sink_init_data = { 0 };
  	struct display_sink_capability sink_caps = { 0 };
@@@ -3627,8 -1874,8 +1874,8 @@@ static void dm_gpureset_commit_state(st
  	}
  }
  
- static void apply_delay_after_dpcd_poweroff(struct amdgpu_device *adev,
- 					    struct dc_sink *sink)
+ void amdgpu_dm_apply_delay_after_dpcd_poweroff(struct amdgpu_device *adev,
+ 											   struct dc_sink *sink)
  {
  	struct dc_panel_patch *ppatch = NULL;
  
@@@ -3771,8 -2018,7 +2018,7 @@@ static int dm_resume(struct amdgpu_ip_b
  		for (i = 0; i < dc_state->stream_count; i++) {
  			dc_state->streams[i]->mode_changed = true;
  			for (j = 0; j < dc_state->stream_status[i].plane_count; j++) {
- 				dc_state->stream_status[i].plane_states[j]->update_flags.raw
- 					= 0xffffffff;
+ 				dc_pipe_update_bits_set_full(&dc_state->stream_status[i].plane_states[j]->update_bits);
  			}
  		}
  
@@@ -3835,7 -2081,7 +2081,7 @@@
  	 */
  	amdgpu_dm_irq_resume_early(adev);
  
- 	s3_handle_hdmi_cec(ddev, false);
+ 	amdgpu_dm_s3_handle_hdmi_cec(ddev, false);
  
  	/* On resume we need to rewrite the MSTM control bits to enable MST*/
  	s3_handle_mst(ddev, false);
@@@ -3870,14 -2116,14 +2116,14 @@@
  			drm_err(adev_to_drm(adev), "KMS: Failed to detect connector\n");
  
  		if (aconnector->base.force && new_connection_type == dc_connection_none) {
- 			emulated_link_detect(aconnector->dc_link);
+ 			amdgpu_dm_emulated_link_detect(aconnector->dc_link);
  		} else {
  			guard(mutex)(&dm->dc_lock);
  			dc_exit_ips_for_hw_access(dm->dc);
  			ret = dc_link_detect(aconnector->dc_link, DETECT_REASON_RESUMEFROMS3S4);
  			if (ret) {
  				/* w/a delay for certain panels */
- 				apply_delay_after_dpcd_poweroff(adev, aconnector->dc_sink);
+ 				amdgpu_dm_apply_delay_after_dpcd_poweroff(adev, aconnector->dc_sink);
  			}
  		}
  
@@@ -3988,1070 -2234,6 +2234,6 @@@ static struct drm_mode_config_helper_fu
  	.atomic_commit_setup = amdgpu_dm_atomic_setup_commit,
  };
  
- #define DDC_MANUFACTURERNAME_SAMSUNG 0x2D4C
- 
- static void dm_set_panel_type(struct amdgpu_dm_connector *aconnector)
- {
- 	struct drm_connector *connector = &aconnector->base;
- 	struct drm_display_info *display_info = &connector->display_info;
- 	struct dc_link *link = aconnector->dc_link;
- 	struct amdgpu_device *adev;
- 
- 	adev = drm_to_adev(connector->dev);
- 
- 	link->panel_type = PANEL_TYPE_NONE;
- 
- 	switch (display_info->amd_vsdb.panel_type) {
- 	case AMD_VSDB_PANEL_TYPE_OLED:
- 		link->panel_type = PANEL_TYPE_OLED;
- 		break;
- 	case AMD_VSDB_PANEL_TYPE_MINILED:
- 		link->panel_type = PANEL_TYPE_MINILED;
- 		break;
- 	}
- 
- 	/* If VSDB didn't determine panel type, check DPCD ext caps */
- 	if (link->panel_type == PANEL_TYPE_NONE) {
- 		if (link->dpcd_sink_ext_caps.bits.miniled == 1)
- 			link->panel_type = PANEL_TYPE_MINILED;
- 		if (link->dpcd_sink_ext_caps.bits.oled == 1)
- 			link->panel_type = PANEL_TYPE_OLED;
- 	}
- 
- 	/* If VSDB and DPCD didn't determine panel type, check DID */
- 	if (link->panel_type == PANEL_TYPE_NONE) {
- 		if (display_info->panel_type == DRM_MODE_PANEL_TYPE_LCD)
- 			link->panel_type = PANEL_TYPE_LCD;
- 		else if (display_info->panel_type == DRM_MODE_PANEL_TYPE_OLED)
- 			link->panel_type = PANEL_TYPE_OLED;
- 	}
- 
- 	if (link->panel_type == PANEL_TYPE_NONE) {
- 		struct drm_amd_vsdb_info *vsdb = &display_info->amd_vsdb;
- 		u32 lum1_max = vsdb->luminance_range1.max_luminance;
- 		u32 lum2_max = vsdb->luminance_range2.max_luminance;
- 
- 		if (vsdb->version && link->local_sink &&
- 		    link->local_sink->edid_caps.manufacturer_id ==
- 		    DDC_MANUFACTURERNAME_SAMSUNG &&
- 		    lum1_max >= ((lum2_max * 3) / 2))
- 			link->panel_type = PANEL_TYPE_MINILED;
- 	}
- 
- 	if (link->panel_type == PANEL_TYPE_OLED)
- 		drm_object_property_set_value(&connector->base,
- 		    adev_to_drm(adev)->mode_config.panel_type_property,
- 		    DRM_MODE_PANEL_TYPE_OLED);
- 	else if (link->panel_type == PANEL_TYPE_LCD)
- 		drm_object_property_set_value(&connector->base,
- 		    adev_to_drm(adev)->mode_config.panel_type_property,
- 		    DRM_MODE_PANEL_TYPE_LCD);
- 	else
- 		drm_object_property_set_value(&connector->base,
- 		    adev_to_drm(adev)->mode_config.panel_type_property,
- 		    DRM_MODE_PANEL_TYPE_UNKNOWN);
- 
- 	drm_dbg_kms(aconnector->base.dev, "Panel type: %d\n", link->panel_type);
- }
- 
- static void update_connector_ext_caps(struct amdgpu_dm_connector *aconnector)
- {
- 	const struct drm_panel_backlight_quirk *panel_backlight_quirk;
- 	struct amdgpu_dm_backlight_caps *caps;
- 	struct drm_connector *conn_base;
- 	struct amdgpu_device *adev;
- 	struct drm_luminance_range_info *luminance_range;
- 	struct drm_device *drm;
- 
- 	if (aconnector->bl_idx == -1 ||
- 	    aconnector->dc_link->connector_signal != SIGNAL_TYPE_EDP)
- 		return;
- 
- 	conn_base = &aconnector->base;
- 	drm = conn_base->dev;
- 	adev = drm_to_adev(drm);
- 
- 	caps = &adev->dm.backlight_caps[aconnector->bl_idx];
- 	caps->ext_caps = &aconnector->dc_link->dpcd_sink_ext_caps;
- 	caps->aux_support = false;
- 
- 	if (caps->ext_caps->bits.oled == 1
- 	    /*
- 	     * ||
- 	     * caps->ext_caps->bits.sdr_aux_backlight_control == 1 ||
- 	     * caps->ext_caps->bits.hdr_aux_backlight_control == 1
- 	     */)
- 		caps->aux_support = true;
- 
- 	if (amdgpu_backlight == 0)
- 		caps->aux_support = false;
- 	else if (amdgpu_backlight == 1)
- 		caps->aux_support = true;
- 	if (caps->aux_support)
- 		aconnector->dc_link->backlight_control_type = BACKLIGHT_CONTROL_AMD_AUX;
- 
- 	luminance_range = &conn_base->display_info.luminance_range;
- 
- 	if (luminance_range->max_luminance)
- 		caps->aux_max_input_signal = luminance_range->max_luminance;
- 	else
- 		caps->aux_max_input_signal = 512;
- 
- 	if (luminance_range->min_luminance)
- 		caps->aux_min_input_signal = luminance_range->min_luminance;
- 	else
- 		caps->aux_min_input_signal = 1;
- 
- 	panel_backlight_quirk =
- 		drm_get_panel_backlight_quirk(aconnector->drm_edid);
- 	if (!IS_ERR_OR_NULL(panel_backlight_quirk)) {
- 		if (panel_backlight_quirk->min_brightness) {
- 			caps->min_input_signal =
- 				panel_backlight_quirk->min_brightness - 1;
- 			drm_info(drm,
- 				 "Applying panel backlight quirk, min_brightness: %d\n",
- 				 caps->min_input_signal);
- 		}
- 		if (panel_backlight_quirk->brightness_mask) {
- 			drm_info(drm,
- 				 "Applying panel backlight quirk, brightness_mask: 0x%X\n",
- 				 panel_backlight_quirk->brightness_mask);
- 			caps->brightness_mask =
- 				panel_backlight_quirk->brightness_mask;
- 		}
- 	}
- }
- 
- DEFINE_FREE(sink_release, struct dc_sink *, if (_T) dc_sink_release(_T))
- 
- void amdgpu_dm_update_connector_after_detect(
- 		struct amdgpu_dm_connector *aconnector)
- {
- 	struct drm_connector *connector = &aconnector->base;
- 	struct dc_sink *sink __free(sink_release) = NULL;
- 	struct drm_device *dev = connector->dev;
- 
- 	/* MST handled by drm_mst framework */
- 	if (aconnector->mst_mgr.mst_state == true)
- 		return;
- 
- 	sink = aconnector->dc_link->local_sink;
- 	if (sink)
- 		dc_sink_retain(sink);
- 
- 	/*
- 	 * Edid mgmt connector gets first update only in mode_valid hook and then
- 	 * the connector sink is set to either fake or physical sink depends on link status.
- 	 * Skip if already done during boot.
- 	 */
- 	if (aconnector->base.force != DRM_FORCE_UNSPECIFIED
- 			&& aconnector->dc_em_sink) {
- 
- 		/*
- 		 * For S3 resume with headless use eml_sink to fake stream
- 		 * because on resume connector->sink is set to NULL
- 		 */
- 		guard(mutex)(&dev->mode_config.mutex);
- 
- 		if (sink) {
- 			if (aconnector->dc_sink) {
- 				amdgpu_dm_update_freesync_caps(connector, NULL, true);
- 				/*
- 				 * retain and release below are used to
- 				 * bump up refcount for sink because the link doesn't point
- 				 * to it anymore after disconnect, so on next crtc to connector
- 				 * reshuffle by UMD we will get into unwanted dc_sink release
- 				 */
- 				dc_sink_release(aconnector->dc_sink);
- 			}
- 			aconnector->dc_sink = sink;
- 			dc_sink_retain(aconnector->dc_sink);
- 			amdgpu_dm_update_freesync_caps(connector,
- 					aconnector->drm_edid, true);
- 		} else {
- 			amdgpu_dm_update_freesync_caps(connector, NULL, true);
- 			if (!aconnector->dc_sink) {
- 				aconnector->dc_sink = aconnector->dc_em_sink;
- 				dc_sink_retain(aconnector->dc_sink);
- 			}
- 		}
- 
- 		return;
- 	}
- 
- 	/*
- 	 * TODO: temporary guard to look for proper fix
- 	 * if this sink is MST sink, we should not do anything
- 	 */
- 	if (sink && sink->sink_signal == SIGNAL_TYPE_DISPLAY_PORT_MST)
- 		return;
- 
- 	if (aconnector->dc_sink == sink) {
- 		/*
- 		 * We got a DP short pulse (Link Loss, DP CTS, etc...).
- 		 * Do nothing!!
- 		 */
- 		drm_dbg_kms(dev, "DCHPD: connector_id=%d: dc_sink didn't change.\n",
- 				 aconnector->connector_id);
- 		return;
- 	}
- 
- 	drm_dbg_kms(dev, "DCHPD: connector_id=%d: Old sink=%p New sink=%p\n",
- 		    aconnector->connector_id, aconnector->dc_sink, sink);
- 
- 	/* When polling, DRM has already locked the mutex for us. */
- 	if (!drm_kms_helper_is_poll_worker())
- 		mutex_lock(&dev->mode_config.mutex);
- 
- 	/*
- 	 * 1. Update status of the drm connector
- 	 * 2. Send an event and let userspace tell us what to do
- 	 */
- 	if (sink) {
- 		/*
- 		 * TODO: check if we still need the S3 mode update workaround.
- 		 * If yes, put it here.
- 		 */
- 		if (aconnector->dc_sink) {
- 			amdgpu_dm_update_freesync_caps(connector, NULL, true);
- 			dc_sink_release(aconnector->dc_sink);
- 		}
- 
- 		aconnector->dc_sink = sink;
- 		dc_sink_retain(aconnector->dc_sink);
- 		drm_edid_free(aconnector->drm_edid);
- 		aconnector->drm_edid = NULL;
- 		if (sink->dc_edid.length == 0) {
- 			hdmi_cec_unset_edid(aconnector);
- 			if (aconnector->dc_link->aux_mode) {
- 				drm_dp_cec_unset_edid(&aconnector->dm_dp_aux.aux);
- 			}
- 		} else {
- 			const struct edid *edid = (const struct edid *)sink->dc_edid.raw_edid;
- 
- 			aconnector->drm_edid = drm_edid_alloc(edid, sink->dc_edid.length);
- 			drm_edid_connector_update(connector, aconnector->drm_edid);
- 
- 			hdmi_cec_set_edid(aconnector);
- 			if (aconnector->dc_link->aux_mode)
- 				drm_dp_cec_attach(&aconnector->dm_dp_aux.aux,
- 						  connector->display_info.source_physical_address);
- 		}
- 
- 		if (!aconnector->timing_requested) {
- 			aconnector->timing_requested =
- 				kzalloc_obj(struct dc_crtc_timing);
- 			if (!aconnector->timing_requested)
- 				drm_err(dev,
- 					"failed to create aconnector->requested_timing\n");
- 		}
- 
- 		amdgpu_dm_update_freesync_caps(connector, aconnector->drm_edid, true);
- 		update_connector_ext_caps(aconnector);
- 		dm_set_panel_type(aconnector);
- 	} else {
- 		hdmi_cec_unset_edid(aconnector);
- 		drm_dp_cec_unset_edid(&aconnector->dm_dp_aux.aux);
- 		amdgpu_dm_update_freesync_caps(connector, NULL, true);
- 		aconnector->num_modes = 0;
- 		dc_sink_release(aconnector->dc_sink);
- 		aconnector->dc_sink = NULL;
- 		drm_edid_free(aconnector->drm_edid);
- 		aconnector->drm_edid = NULL;
- 		kfree(aconnector->timing_requested);
- 		aconnector->timing_requested = NULL;
- 		/* Set CP to DESIRED if it was ENABLED, so we can re-enable it again on hotplug */
- 		if (connector->state->content_protection == DRM_MODE_CONTENT_PROTECTION_ENABLED)
- 			connector->state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
- 	}
- 
- 	update_subconnector_property(aconnector);
- 
- 	/* When polling, the mutex will be unlocked for us by DRM. */
- 	if (!drm_kms_helper_is_poll_worker())
- 		mutex_unlock(&dev->mode_config.mutex);
- }
- 
- static bool are_sinks_equal(const struct dc_sink *sink1, const struct dc_sink *sink2)
- {
- 	if (!sink1 || !sink2)
- 		return false;
- 	if (sink1->sink_signal != sink2->sink_signal)
- 		return false;
- 
- 	if (sink1->dc_edid.length != sink2->dc_edid.length)
- 		return false;
- 
- 	if (memcmp(sink1->dc_edid.raw_edid, sink2->dc_edid.raw_edid,
- 		   sink1->dc_edid.length) != 0)
- 		return false;
- 	return true;
- }
- 
- 
- /**
-  * DOC: hdmi_hpd_debounce_work
-  *
-  * HDMI HPD debounce delay in milliseconds. When an HDMI display toggles HPD
-  * (such as during power save transitions), this delay determines how long to
-  * wait before processing the HPD event. This allows distinguishing between a
-  * physical unplug (>hdmi_hpd_debounce_delay)
-  * and a spontaneous RX HPD toggle (<hdmi_hpd_debounce_delay).
-  *
-  * If the toggle is less than this delay, the driver compares sink capabilities
-  * and permits a hotplug event if they changed.
-  *
-  * The default value of 1500ms was chosen based on experimental testing with
-  * various monitors that exhibit spontaneous HPD toggling behavior.
-  */
- static void hdmi_hpd_debounce_work(struct work_struct *work)
- {
- 	struct amdgpu_dm_connector *aconnector =
- 		container_of(to_delayed_work(work), struct amdgpu_dm_connector,
- 			     hdmi_hpd_debounce_work);
- 	struct drm_connector *connector = &aconnector->base;
- 	struct drm_device *dev = connector->dev;
- 	struct amdgpu_device *adev = drm_to_adev(dev);
- 	struct dc *dc = aconnector->dc_link->ctx->dc;
- 	bool fake_reconnect = false;
- 	bool reallow_idle = false;
- 	bool ret = false;
- 	guard(mutex)(&aconnector->hpd_lock);
- 
- 	/* Re-detect the display */
- 	scoped_guard(mutex, &adev->dm.dc_lock) {
- 		if (dc->caps.ips_support && dc->ctx->dmub_srv->idle_allowed) {
- 			dc_allow_idle_optimizations(dc, false);
- 			reallow_idle = true;
- 		}
- 		ret = dc_link_detect(aconnector->dc_link, DETECT_REASON_HPD);
- 	}
- 
- 	if (ret) {
- 		/* Apply workaround delay for certain panels */
- 		apply_delay_after_dpcd_poweroff(adev, aconnector->dc_sink);
- 		/* Compare sinks to determine if this was a spontaneous HPD toggle */
- 		if (are_sinks_equal(aconnector->dc_link->local_sink, aconnector->hdmi_prev_sink)) {
- 			/*
- 			* Sinks match - this was a spontaneous HDMI HPD toggle.
- 			*/
- 			drm_dbg_kms(dev, "HDMI HPD: Sink unchanged after debounce, internal re-enable\n");
- 			fake_reconnect = true;
- 		}
- 
- 		/* Update connector state */
- 		amdgpu_dm_update_connector_after_detect(aconnector);
- 
- 		drm_modeset_lock_all(dev);
- 		dm_restore_drm_connector_state(dev, connector);
- 		drm_modeset_unlock_all(dev);
- 
- 		/* Only notify OS if sink actually changed */
- 		if (!fake_reconnect && aconnector->base.force == DRM_FORCE_UNSPECIFIED)
- 			drm_kms_helper_hotplug_event(dev);
- 	}
- 
- 	/* Release the cached sink reference */
- 	if (aconnector->hdmi_prev_sink) {
- 		dc_sink_release(aconnector->hdmi_prev_sink);
- 		aconnector->hdmi_prev_sink = NULL;
- 	}
- 
- 	scoped_guard(mutex, &adev->dm.dc_lock) {
- 		if (reallow_idle && dc->caps.ips_support)
- 			dc_allow_idle_optimizations(dc, true);
- 	}
- }
- 
- static void handle_hpd_irq_helper(struct amdgpu_dm_connector *aconnector)
- {
- 	struct drm_connector *connector = &aconnector->base;
- 	struct drm_device *dev = connector->dev;
- 	enum dc_connection_type new_connection_type = dc_connection_none;
- 	struct amdgpu_device *adev = drm_to_adev(dev);
- 	struct dm_connector_state *dm_con_state = to_dm_connector_state(connector->state);
- 	struct dc *dc = aconnector->dc_link->ctx->dc;
- 	bool ret = false;
- 	bool debounce_required = false;
- 
- 	if (adev->dm.disable_hpd_irq)
- 		return;
- 
- 	/*
- 	 * In case of failure or MST no need to update connector status or notify the OS
- 	 * since (for MST case) MST does this in its own context.
- 	 */
- 	guard(mutex)(&aconnector->hpd_lock);
- 
- 	if (adev->dm.hdcp_workqueue) {
- 		hdcp_reset_display(adev->dm.hdcp_workqueue, aconnector->dc_link->link_index);
- 		dm_con_state->update_hdcp = true;
- 	}
- 	if (aconnector->fake_enable)
- 		aconnector->fake_enable = false;
- 
- 	aconnector->timing_changed = false;
- 
- 	if (!dc_link_detect_connection_type(aconnector->dc_link, &new_connection_type))
- 		drm_err(adev_to_drm(adev), "KMS: Failed to detect connector\n");
- 
- 	/*
- 	 * Check for HDMI disconnect with debounce enabled.
- 	 */
- 	debounce_required = (aconnector->hdmi_hpd_debounce_delay_ms > 0 &&
- 			      dc_is_hdmi_signal(aconnector->dc_link->connector_signal) &&
- 			      new_connection_type == dc_connection_none &&
- 			      aconnector->dc_link->local_sink != NULL);
- 
- 	if (aconnector->base.force && new_connection_type == dc_connection_none) {
- 		emulated_link_detect(aconnector->dc_link);
- 
- 		drm_modeset_lock_all(dev);
- 		dm_restore_drm_connector_state(dev, connector);
- 		drm_modeset_unlock_all(dev);
- 
- 		if (aconnector->base.force == DRM_FORCE_UNSPECIFIED)
- 			drm_kms_helper_connector_hotplug_event(connector);
- 	} else if (debounce_required) {
- 		/*
- 		 * HDMI disconnect detected - schedule delayed work instead of
- 		 * processing immediately. This allows us to coalesce spurious
- 		 * HDMI signals from physical unplugs.
- 		 */
- 		drm_dbg_kms(dev, "HDMI HPD: Disconnect detected, scheduling debounce work (%u ms)\n",
- 			    aconnector->hdmi_hpd_debounce_delay_ms);
- 
- 		/* Cache the current sink for later comparison */
- 		if (aconnector->hdmi_prev_sink)
- 			dc_sink_release(aconnector->hdmi_prev_sink);
- 		aconnector->hdmi_prev_sink = aconnector->dc_link->local_sink;
- 		if (aconnector->hdmi_prev_sink)
- 			dc_sink_retain(aconnector->hdmi_prev_sink);
- 
- 		/* Schedule delayed detection. */
- 		if (mod_delayed_work(system_percpu_wq,
- 				 &aconnector->hdmi_hpd_debounce_work,
- 				 msecs_to_jiffies(aconnector->hdmi_hpd_debounce_delay_ms)))
- 			drm_dbg_kms(dev, "HDMI HPD: Re-scheduled debounce work\n");
- 
- 	} else {
- 
- 		/* If the aconnector->hdmi_hpd_debounce_work is scheduled, exit early */
- 		if (delayed_work_pending(&aconnector->hdmi_hpd_debounce_work))
- 			return;
- 
- 		scoped_guard(mutex, &adev->dm.dc_lock) {
- 			dc_exit_ips_for_hw_access(dc);
- 			ret = dc_link_detect(aconnector->dc_link, DETECT_REASON_HPD);
- 		}
- 		if (ret) {
- 			/* w/a delay for certain panels */
- 			apply_delay_after_dpcd_poweroff(adev, aconnector->dc_sink);
- 			amdgpu_dm_update_connector_after_detect(aconnector);
- 
- 			drm_modeset_lock_all(dev);
- 			dm_restore_drm_connector_state(dev, connector);
- 			drm_modeset_unlock_all(dev);
- 
- 			if (aconnector->base.force == DRM_FORCE_UNSPECIFIED)
- 				drm_kms_helper_connector_hotplug_event(connector);
- 		}
- 	}
- }
- 
- static void handle_hpd_irq(void *param)
- {
- 	struct amdgpu_dm_connector *aconnector = (struct amdgpu_dm_connector *)param;
- 
- 	handle_hpd_irq_helper(aconnector);
- 
- }
- 
- static void schedule_hpd_rx_offload_work(struct amdgpu_device *adev, struct hpd_rx_irq_offload_work_queue *offload_wq,
- 							union hpd_irq_data hpd_irq_data)
- {
- 	struct hpd_rx_irq_offload_work *offload_work = kzalloc_obj(*offload_work);
- 
- 	if (!offload_work) {
- 		drm_err(adev_to_drm(adev), "Failed to allocate hpd_rx_irq_offload_work.\n");
- 		return;
- 	}
- 
- 	INIT_WORK(&offload_work->work, dm_handle_hpd_rx_offload_work);
- 	offload_work->data = hpd_irq_data;
- 	offload_work->offload_wq = offload_wq;
- 	offload_work->adev = adev;
- 
- 	queue_work(offload_wq->wq, &offload_work->work);
- 	drm_dbg_kms(adev_to_drm(adev), "queue work to handle hpd_rx offload work");
- }
- 
- static void handle_hpd_rx_irq(void *param)
- {
- 	struct amdgpu_dm_connector *aconnector = (struct amdgpu_dm_connector *)param;
- 	struct drm_connector *connector = &aconnector->base;
- 	struct drm_device *dev = connector->dev;
- 	struct dc_link *dc_link = aconnector->dc_link;
- 	bool is_mst_root_connector = aconnector->mst_mgr.mst_state;
- 	bool result = false;
- 	enum dc_connection_type new_connection_type = dc_connection_none;
- 	struct amdgpu_device *adev = drm_to_adev(dev);
- 	union hpd_irq_data hpd_irq_data;
- 	bool link_loss = false;
- 	bool has_left_work = false;
- 	int idx = dc_link->link_index;
- 	struct hpd_rx_irq_offload_work_queue *offload_wq = &adev->dm.hpd_rx_offload_wq[idx];
- 	struct dc *dc = aconnector->dc_link->ctx->dc;
- 
- 	memset(&hpd_irq_data, 0, sizeof(hpd_irq_data));
- 
- 	if (adev->dm.disable_hpd_irq)
- 		return;
- 
- 	/*
- 	 * TODO:Temporary add mutex to protect hpd interrupt not have a gpio
- 	 * conflict, after implement i2c helper, this mutex should be
- 	 * retired.
- 	 */
- 	mutex_lock(&aconnector->hpd_lock);
- 
- 	result = dc_link_handle_hpd_rx_irq(dc_link, &hpd_irq_data,
- 						&link_loss, true, &has_left_work);
- 
- 	if (!has_left_work)
- 		goto out;
- 
- 	if (hpd_irq_data.bytes.device_service_irq.bits.AUTOMATED_TEST) {
- 		schedule_hpd_rx_offload_work(adev, offload_wq, hpd_irq_data);
- 		goto out;
- 	}
- 
- 	if (dc_link_dp_allow_hpd_rx_irq(dc_link)) {
- 		if (hpd_irq_data.bytes.device_service_irq.bits.UP_REQ_MSG_RDY ||
- 			hpd_irq_data.bytes.device_service_irq.bits.DOWN_REP_MSG_RDY) {
- 			bool skip = false;
- 
- 			/*
- 			 * DOWN_REP_MSG_RDY is also handled by polling method
- 			 * mgr->cbs->poll_hpd_irq()
- 			 */
- 			spin_lock(&offload_wq->offload_lock);
- 			skip = offload_wq->is_handling_mst_msg_rdy_event;
- 
- 			if (!skip)
- 				offload_wq->is_handling_mst_msg_rdy_event = true;
- 
- 			spin_unlock(&offload_wq->offload_lock);
- 
- 			if (!skip)
- 				schedule_hpd_rx_offload_work(adev, offload_wq, hpd_irq_data);
- 
- 			goto out;
- 		}
- 
- 		if (link_loss) {
- 			bool skip = false;
- 
- 			spin_lock(&offload_wq->offload_lock);
- 			skip = offload_wq->is_handling_link_loss;
- 
- 			if (!skip)
- 				offload_wq->is_handling_link_loss = true;
- 
- 			spin_unlock(&offload_wq->offload_lock);
- 
- 			if (!skip)
- 				schedule_hpd_rx_offload_work(adev, offload_wq, hpd_irq_data);
- 
- 			goto out;
- 		}
- 	}
- 
- out:
- 	if (result && !is_mst_root_connector) {
- 		/* Downstream Port status changed. */
- 		if (!dc_link_detect_connection_type(dc_link, &new_connection_type))
- 			drm_err(adev_to_drm(adev), "KMS: Failed to detect connector\n");
- 
- 		if (aconnector->base.force && new_connection_type == dc_connection_none) {
- 			emulated_link_detect(dc_link);
- 
- 			if (aconnector->fake_enable)
- 				aconnector->fake_enable = false;
- 
- 			amdgpu_dm_update_connector_after_detect(aconnector);
- 
- 
- 			drm_modeset_lock_all(dev);
- 			dm_restore_drm_connector_state(dev, connector);
- 			drm_modeset_unlock_all(dev);
- 
- 			drm_kms_helper_connector_hotplug_event(connector);
- 		} else {
- 			bool ret = false;
- 
- 			mutex_lock(&adev->dm.dc_lock);
- 			dc_exit_ips_for_hw_access(dc);
- 			ret = dc_link_detect(dc_link, DETECT_REASON_HPDRX);
- 			mutex_unlock(&adev->dm.dc_lock);
- 
- 			if (ret) {
- 				if (aconnector->fake_enable)
- 					aconnector->fake_enable = false;
- 
- 				amdgpu_dm_update_connector_after_detect(aconnector);
- 
- 				drm_modeset_lock_all(dev);
- 				dm_restore_drm_connector_state(dev, connector);
- 				drm_modeset_unlock_all(dev);
- 
- 				drm_kms_helper_connector_hotplug_event(connector);
- 			}
- 		}
- 	}
- 	if (hpd_irq_data.bytes.device_service_irq.bits.CP_IRQ) {
- 		if (adev->dm.hdcp_workqueue)
- 			hdcp_handle_cpirq(adev->dm.hdcp_workqueue,  aconnector->base.index);
- 	}
- 
- 	if (dc_link->type != dc_connection_mst_branch)
- 		drm_dp_cec_irq(&aconnector->dm_dp_aux.aux);
- 
- 	mutex_unlock(&aconnector->hpd_lock);
- }
- 
- static int register_hpd_handlers(struct amdgpu_device *adev)
- {
- 	struct drm_device *dev = adev_to_drm(adev);
- 	struct drm_connector *connector;
- 	struct amdgpu_dm_connector *aconnector;
- 	const struct dc_link *dc_link;
- 	struct dc_interrupt_params int_params = {0};
- 
- 	int_params.requested_polarity = INTERRUPT_POLARITY_DEFAULT;
- 	int_params.current_polarity = INTERRUPT_POLARITY_DEFAULT;
- 
- 	if (dc_is_dmub_outbox_supported(adev->dm.dc)) {
- 		if (!register_dmub_notify_callback(adev, DMUB_NOTIFICATION_HPD,
- 			dmub_hpd_callback, true)) {
- 			drm_err(adev_to_drm(adev), "fail to register dmub hpd callback");
- 			return -EINVAL;
- 		}
- 
- 		if (!register_dmub_notify_callback(adev, DMUB_NOTIFICATION_HPD_IRQ,
- 			dmub_hpd_callback, true)) {
- 			drm_err(adev_to_drm(adev), "fail to register dmub hpd callback");
- 			return -EINVAL;
- 		}
- 
- 		if (!register_dmub_notify_callback(adev, DMUB_NOTIFICATION_HPD_SENSE_NOTIFY,
- 			dmub_hpd_sense_callback, true)) {
- 			drm_err(adev_to_drm(adev), "fail to register dmub hpd sense callback");
- 			return -EINVAL;
- 		}
- 	}
- 
- 	list_for_each_entry(connector,
- 			&dev->mode_config.connector_list, head)	{
- 
- 		if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
- 			continue;
- 
- 		aconnector = to_amdgpu_dm_connector(connector);
- 		dc_link = aconnector->dc_link;
- 
- 		if (dc_link->irq_source_hpd != DC_IRQ_SOURCE_INVALID) {
- 			int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
- 			int_params.irq_source = dc_link->irq_source_hpd;
- 
- 			if (int_params.irq_source == DC_IRQ_SOURCE_INVALID ||
- 				int_params.irq_source  < DC_IRQ_SOURCE_HPD1 ||
- 				int_params.irq_source  > DC_IRQ_SOURCE_HPD6) {
- 				drm_err(adev_to_drm(adev), "Failed to register hpd irq!\n");
- 				return -EINVAL;
- 			}
- 
- 			if (!amdgpu_dm_irq_register_interrupt(adev, &int_params,
- 				handle_hpd_irq, (void *) aconnector))
- 				return -ENOMEM;
- 		}
- 
- 		if (dc_link->irq_source_hpd_rx != DC_IRQ_SOURCE_INVALID) {
- 
- 			/* Also register for DP short pulse (hpd_rx). */
- 			int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
- 			int_params.irq_source =	dc_link->irq_source_hpd_rx;
- 
- 			if (int_params.irq_source == DC_IRQ_SOURCE_INVALID ||
- 				int_params.irq_source  < DC_IRQ_SOURCE_HPD1RX ||
- 				int_params.irq_source  > DC_IRQ_SOURCE_HPD6RX) {
- 				drm_err(adev_to_drm(adev), "Failed to register hpd rx irq!\n");
- 				return -EINVAL;
- 			}
- 
- 			if (!amdgpu_dm_irq_register_interrupt(adev, &int_params,
- 				handle_hpd_rx_irq, (void *) aconnector))
- 				return -ENOMEM;
- 		}
- 	}
- 	return 0;
- }
- 
- /* Register IRQ sources and initialize IRQ callbacks */
- static int dce110_register_irq_handlers(struct amdgpu_device *adev)
- {
- 	struct dc *dc = adev->dm.dc;
- 	struct common_irq_params *c_irq_params;
- 	struct dc_interrupt_params int_params = {0};
- 	int r;
- 	int i;
- 	unsigned int src_id;
- 	unsigned int client_id = AMDGPU_IRQ_CLIENTID_LEGACY;
- 	/* Use different interrupts for VBLANK on DCE 6 vs. newer. */
- 	const unsigned int vblank_d1 =
- 		adev->dm.dc->ctx->dce_version >= DCE_VERSION_8_0
- 		? VISLANDS30_IV_SRCID_D1_VERTICAL_INTERRUPT0 : 1;
- 
- 	if (adev->family >= AMDGPU_FAMILY_AI)
- 		client_id = SOC15_IH_CLIENTID_DCE;
- 
- 	int_params.requested_polarity = INTERRUPT_POLARITY_DEFAULT;
- 	int_params.current_polarity = INTERRUPT_POLARITY_DEFAULT;
- 
- 	/*
- 	 * Actions of amdgpu_irq_add_id():
- 	 * 1. Register a set() function with base driver.
- 	 *    Base driver will call set() function to enable/disable an
- 	 *    interrupt in DC hardware.
- 	 * 2. Register amdgpu_dm_irq_handler().
- 	 *    Base driver will call amdgpu_dm_irq_handler() for ALL interrupts
- 	 *    coming from DC hardware.
- 	 *    amdgpu_dm_irq_handler() will re-direct the interrupt to DC
- 	 *    for acknowledging and handling.
- 	 */
- 
- 	/* Use VBLANK interrupt */
- 	for (i = 0; i < adev->mode_info.num_crtc; i++) {
- 		src_id = vblank_d1 + i;
- 		r = amdgpu_irq_add_id(adev, client_id, src_id, &adev->crtc_irq);
- 		if (r) {
- 			drm_err(adev_to_drm(adev), "Failed to add crtc irq id!\n");
- 			return r;
- 		}
- 
- 		int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
- 		int_params.irq_source =
- 			dc_interrupt_to_irq_source(dc, src_id, 0);
- 
- 		if (int_params.irq_source == DC_IRQ_SOURCE_INVALID ||
- 			int_params.irq_source  < DC_IRQ_SOURCE_VBLANK1 ||
- 			int_params.irq_source  > DC_IRQ_SOURCE_VBLANK6) {
- 			drm_err(adev_to_drm(adev), "Failed to register vblank irq!\n");
- 			return -EINVAL;
- 		}
- 
- 		c_irq_params = &adev->dm.vblank_params[int_params.irq_source - DC_IRQ_SOURCE_VBLANK1];
- 
- 		c_irq_params->adev = adev;
- 		c_irq_params->irq_src = int_params.irq_source;
- 
- 		if (!amdgpu_dm_irq_register_interrupt(adev, &int_params,
- 			dm_crtc_high_irq, c_irq_params))
- 			return -ENOMEM;
- 	}
- 
- 	if (dc_supports_vrr(adev->dm.dc->ctx->dce_version)) {
- 		/* Use VUPDATE interrupt */
- 		for (i = 0; i < adev->mode_info.num_crtc; i++) {
- 			src_id = VISLANDS30_IV_SRCID_D1_V_UPDATE_INT + i * 2;
- 			r = amdgpu_irq_add_id(adev, client_id, src_id, &adev->vupdate_irq);
- 			if (r) {
- 				drm_err(adev_to_drm(adev), "Failed to add vupdate irq id!\n");
- 				return r;
- 			}
- 
- 			int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
- 			int_params.irq_source =
- 				dc_interrupt_to_irq_source(dc, src_id, 0);
- 
- 			if (int_params.irq_source == DC_IRQ_SOURCE_INVALID ||
- 				int_params.irq_source  < DC_IRQ_SOURCE_VUPDATE1 ||
- 				int_params.irq_source  > DC_IRQ_SOURCE_VUPDATE6) {
- 				drm_err(adev_to_drm(adev), "Failed to register vupdate irq!\n");
- 				return -EINVAL;
- 			}
- 
- 			c_irq_params = &adev->dm.vupdate_params[
- 				int_params.irq_source - DC_IRQ_SOURCE_VUPDATE1];
- 			c_irq_params->adev = adev;
- 			c_irq_params->irq_src = int_params.irq_source;
- 
- 			if (!amdgpu_dm_irq_register_interrupt(adev, &int_params,
- 				dm_vupdate_high_irq, c_irq_params))
- 				return -ENOMEM;
- 		}
- 	}
- 
- 	/* Use GRPH_PFLIP interrupt */
- 	for (i = VISLANDS30_IV_SRCID_D1_GRPH_PFLIP;
- 			i <= VISLANDS30_IV_SRCID_D6_GRPH_PFLIP; i += 2) {
- 		r = amdgpu_irq_add_id(adev, client_id, i, &adev->pageflip_irq);
- 		if (r) {
- 			drm_err(adev_to_drm(adev), "Failed to add page flip irq id!\n");
- 			return r;
- 		}
- 
- 		int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
- 		int_params.irq_source =
- 			dc_interrupt_to_irq_source(dc, i, 0);
- 
- 		if (int_params.irq_source == DC_IRQ_SOURCE_INVALID ||
- 			int_params.irq_source  < DC_IRQ_SOURCE_PFLIP_FIRST ||
- 			int_params.irq_source  > DC_IRQ_SOURCE_PFLIP_LAST) {
- 			drm_err(adev_to_drm(adev), "Failed to register pflip irq!\n");
- 			return -EINVAL;
- 		}
- 
- 		c_irq_params = &adev->dm.pflip_params[int_params.irq_source - DC_IRQ_SOURCE_PFLIP_FIRST];
- 
- 		c_irq_params->adev = adev;
- 		c_irq_params->irq_src = int_params.irq_source;
- 
- 		if (!amdgpu_dm_irq_register_interrupt(adev, &int_params,
- 			dm_pflip_high_irq, c_irq_params))
- 			return -ENOMEM;
- 	}
- 
- 	/* HPD */
- 	r = amdgpu_irq_add_id(adev, client_id,
- 			VISLANDS30_IV_SRCID_HOTPLUG_DETECT_A, &adev->hpd_irq);
- 	if (r) {
- 		drm_err(adev_to_drm(adev), "Failed to add hpd irq id!\n");
- 		return r;
- 	}
- 
- 	r = register_hpd_handlers(adev);
- 
- 	return r;
- }
- 
- /* Register IRQ sources and initialize IRQ callbacks */
- static int dcn10_register_irq_handlers(struct amdgpu_device *adev)
- {
- 	struct dc *dc = adev->dm.dc;
- 	struct common_irq_params *c_irq_params;
- 	struct dc_interrupt_params int_params = {0};
- 	int r;
- 	int i;
- #if defined(CONFIG_DRM_AMD_SECURE_DISPLAY)
- 	static const unsigned int vrtl_int_srcid[] = {
- 		DCN_1_0__SRCID__OTG1_VERTICAL_INTERRUPT0_CONTROL,
- 		DCN_1_0__SRCID__OTG2_VERTICAL_INTERRUPT0_CONTROL,
- 		DCN_1_0__SRCID__OTG3_VERTICAL_INTERRUPT0_CONTROL,
- 		DCN_1_0__SRCID__OTG4_VERTICAL_INTERRUPT0_CONTROL,
- 		DCN_1_0__SRCID__OTG5_VERTICAL_INTERRUPT0_CONTROL,
- 		DCN_1_0__SRCID__OTG6_VERTICAL_INTERRUPT0_CONTROL
- 	};
- #endif
- 
- 	int_params.requested_polarity = INTERRUPT_POLARITY_DEFAULT;
- 	int_params.current_polarity = INTERRUPT_POLARITY_DEFAULT;
- 
- 	/*
- 	 * Actions of amdgpu_irq_add_id():
- 	 * 1. Register a set() function with base driver.
- 	 *    Base driver will call set() function to enable/disable an
- 	 *    interrupt in DC hardware.
- 	 * 2. Register amdgpu_dm_irq_handler().
- 	 *    Base driver will call amdgpu_dm_irq_handler() for ALL interrupts
- 	 *    coming from DC hardware.
- 	 *    amdgpu_dm_irq_handler() will re-direct the interrupt to DC
- 	 *    for acknowledging and handling.
- 	 */
- 
- 	/* Use VSTARTUP interrupt */
- 	for (i = DCN_1_0__SRCID__DC_D1_OTG_VSTARTUP;
- 			i <= DCN_1_0__SRCID__DC_D1_OTG_VSTARTUP + adev->mode_info.num_crtc - 1;
- 			i++) {
- 		r = amdgpu_irq_add_id(adev, SOC15_IH_CLIENTID_DCE, i, &adev->crtc_irq);
- 
- 		if (r) {
- 			drm_err(adev_to_drm(adev), "Failed to add crtc irq id!\n");
- 			return r;
- 		}
- 
- 		int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
- 		int_params.irq_source =
- 			dc_interrupt_to_irq_source(dc, i, 0);
- 
- 		if (int_params.irq_source == DC_IRQ_SOURCE_INVALID ||
- 			int_params.irq_source  < DC_IRQ_SOURCE_VBLANK1 ||
- 			int_params.irq_source  > DC_IRQ_SOURCE_VBLANK6) {
- 			drm_err(adev_to_drm(adev), "Failed to register vblank irq!\n");
- 			return -EINVAL;
- 		}
- 
- 		c_irq_params = &adev->dm.vblank_params[int_params.irq_source - DC_IRQ_SOURCE_VBLANK1];
- 
- 		c_irq_params->adev = adev;
- 		c_irq_params->irq_src = int_params.irq_source;
- 
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Part of the diff is not shown here. View the raw message.