[Intel-gfx] [PATCH] drm/atomic: Acquire connection_mutex lock in drm_helper_probe_single_connector_modes, v3.

Daniel Vetter daniel at ffwll.ch
Wed Apr 5 09:08:06 UTC 2017


On Wed, Apr 05, 2017 at 10:11:18AM +0200, Maarten Lankhorst wrote:
> mode_valid() called from drm_helper_probe_single_connector_modes()
> may need to look at connector->state because what a valid mode is may
> depend on connector properties being set. For example some HDMI modes
> might be rejected when a connector property forces the connector
> into DVI mode.
> 
> Some implementations of detect() already lock all state,
> so we have to pass an acquire_ctx to them to prevent a deadlock.
> 
> This means changing the function signature of detect() slightly,
> and passing the acquire_ctx for locking multiple crtc's.
> For the callbacks, it will always be non-zero. To allow callers
> not to worry about this, drm_helper_probe_detect_ctx is added
> which might handle -EDEADLK for you.
> 
> Changes since v1:
> - Always set ctx parameter.
> Changes since v2:
> - Always take connection_mutex when probing.
> 
> Signed-off-by: Maarten Lankhorst <maarten.lankhorst at linux.intel.com>
> Cc: Boris Brezillon <boris.brezillon at free-electrons.com>

A few minor nits, mostly to improve checks and docs. With those all
addressed:

Reviewed-by: Daniel Vetter <daniel.vetter at ffwll.ch>

> ---
>  Fixed drm_helper_probe_detect,
>  is this version better?
>  drivers/gpu/drm/drm_probe_helper.c       | 100 ++++++++++++++++++++++++++++---
>  drivers/gpu/drm/i915/intel_crt.c         |  25 ++++----
>  drivers/gpu/drm/i915/intel_display.c     |  25 ++++----
>  drivers/gpu/drm/i915/intel_dp.c          |  24 ++++----
>  drivers/gpu/drm/i915/intel_drv.h         |   8 +--
>  drivers/gpu/drm/i915/intel_hotplug.c     |   3 +-
>  drivers/gpu/drm/i915/intel_tv.c          |  21 +++----
>  include/drm/drm_connector.h              |   5 ++
>  include/drm/drm_crtc_helper.h            |   3 +
>  include/drm/drm_modeset_helper_vtables.h |  24 ++++++++
>  10 files changed, 175 insertions(+), 63 deletions(-)
> 
> diff --git a/drivers/gpu/drm/drm_probe_helper.c b/drivers/gpu/drm/drm_probe_helper.c
> index efb5e5e8ce62..ba0160446aac 100644
> --- a/drivers/gpu/drm/drm_probe_helper.c
> +++ b/drivers/gpu/drm/drm_probe_helper.c
> @@ -169,12 +169,73 @@ void drm_kms_helper_poll_enable(struct drm_device *dev)
>  EXPORT_SYMBOL(drm_kms_helper_poll_enable);
>  
>  static enum drm_connector_status
> -drm_connector_detect(struct drm_connector *connector, bool force)
> +drm_helper_probe_detect_ctx(struct drm_connector *connector, bool force)
>  {
> -	return connector->funcs->detect ?
> -		connector->funcs->detect(connector, force) :
> -		connector_status_connected;
> +	const struct drm_connector_helper_funcs *funcs = connector->helper_private;
> +	struct drm_modeset_acquire_ctx ctx;
> +	int ret;
> +
> +	drm_modeset_acquire_init(&ctx, 0);
> +
> +retry:
> +	ret = drm_modeset_lock(&connector->dev->mode_config.connection_mutex, &ctx);
> +	if (!ret) {
> +		if (funcs->detect_ctx)
> +			ret = funcs->detect_ctx(connector, &ctx, force);
> +		else if (connector->funcs->detect)
> +			ret = connector->funcs->detect(connector, force);
> +		else
> +			ret = connector_status_connected;
> +	}
> +
> +	if (ret == -EDEADLK) {
> +		drm_modeset_backoff(&ctx);
> +		goto retry;
> +	}
> +
> +	if (WARN_ON(ret < 0))
> +		ret = connector_status_unknown;
> +
> +	drm_modeset_drop_locks(&ctx);
> +	drm_modeset_acquire_fini(&ctx);
> +
> +	return ret;
> +}
> +
> +/**
> + * drm_helper_probe_detect - probe connector status
> + * @connector: connector to probe
> + * @ctx: acquire_ctx, or NULL to let this function handle locking.
> + * @force: Whether destructive probe operations should be performed.
> + *
> + * This function calls the detect callbacks of the connector.
> + * This function returns drm_connector_status, or
> + * if @ctx is set, it might also return -EDEADLK.
> + */
> +int
> +drm_helper_probe_detect(struct drm_connector *connector,
> +			struct drm_modeset_acquire_ctx *ctx,
> +			bool force)
> +{
> +	const struct drm_connector_helper_funcs *funcs = connector->helper_private;
> +	struct drm_device *dev = connector->dev;
> +	int ret;
> +
> +	if (!ctx)
> +		return drm_helper_probe_detect_ctx(connector, force);
> +
> +	ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
> +	if (ret)
> +		return ret;
> +
> +	if (funcs->detect_ctx)
> +		return funcs->detect_ctx(connector, ctx, force);
> +	else if (connector->funcs->detect)
> +		return connector->funcs->detect(connector, force);
> +	else
> +		return connector_status_connected;
>  }
> +EXPORT_SYMBOL(drm_helper_probe_detect);
>  
>  /**
>   * drm_helper_probe_single_connector_modes - get complete set of display modes
> @@ -239,15 +300,27 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
>  	struct drm_display_mode *mode;
>  	const struct drm_connector_helper_funcs *connector_funcs =
>  		connector->helper_private;
> -	int count = 0;
> +	int count = 0, ret;
>  	int mode_flags = 0;
>  	bool verbose_prune = true;
>  	enum drm_connector_status old_status;
> +	struct drm_modeset_acquire_ctx ctx;
>  
>  	WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
>  
> +	drm_modeset_acquire_init(&ctx, 0);
> +
>  	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
>  			connector->name);
> +
> +retry:
> +	ret = drm_modeset_lock(&dev->mode_config.connection_mutex, &ctx);
> +	if (ret == -EDEADLK) {
> +		drm_modeset_backoff(&ctx);
> +		goto retry;
> +	} else
> +		WARN_ON(ret < 0);
> +
>  	/* set all old modes to the stale state */
>  	list_for_each_entry(mode, &connector->modes, head)
>  		mode->status = MODE_STALE;
> @@ -263,7 +336,15 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
>  		if (connector->funcs->force)
>  			connector->funcs->force(connector);
>  	} else {
> -		connector->status = drm_connector_detect(connector, true);
> +		ret = drm_helper_probe_detect(connector, &ctx, true);
> +
> +		if (ret == -EDEADLK) {
> +			drm_modeset_backoff(&ctx);
> +			goto retry;
> +		} else if (WARN(ret < 0, "Invalid return value %i for connector detection\n", ret))
> +			ret = connector_status_unknown;
> +
> +		connector->status = ret;
>  	}
>  
>  	/*
> @@ -355,6 +436,9 @@ int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
>  prune:
>  	drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);
>  
> +	drm_modeset_drop_locks(&ctx);
> +	drm_modeset_acquire_fini(&ctx);
> +
>  	if (list_empty(&connector->modes))
>  		return 0;
>  
> @@ -440,7 +524,7 @@ static void output_poll_execute(struct work_struct *work)
>  
>  		repoll = true;
>  
> -		connector->status = drm_connector_detect(connector, false);
> +		connector->status = drm_helper_probe_detect(connector, NULL, false);
>  		if (old_status != connector->status) {
>  			const char *old, *new;
>  
> @@ -588,7 +672,7 @@ bool drm_helper_hpd_irq_event(struct drm_device *dev)
>  
>  		old_status = connector->status;
>  
> -		connector->status = drm_connector_detect(connector, false);
> +		connector->status = drm_helper_probe_detect(connector, NULL, false);
>  		DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
>  			      connector->base.id,
>  			      connector->name,
> diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
> index 8c82607294c6..2797bf37c3ac 100644
> --- a/drivers/gpu/drm/i915/intel_crt.c
> +++ b/drivers/gpu/drm/i915/intel_crt.c
> @@ -669,15 +669,16 @@ static const struct dmi_system_id intel_spurious_crt_detect[] = {
>  	{ }
>  };
>  
> -static enum drm_connector_status
> -intel_crt_detect(struct drm_connector *connector, bool force)
> +static int
> +intel_crt_detect(struct drm_connector *connector,
> +		 struct drm_modeset_acquire_ctx *ctx,
> +		 bool force)
>  {
>  	struct drm_i915_private *dev_priv = to_i915(connector->dev);
>  	struct intel_crt *crt = intel_attached_crt(connector);
>  	struct intel_encoder *intel_encoder = &crt->base;
> -	enum drm_connector_status status;
> +	int status, ret;
>  	struct intel_load_detect_pipe tmp;
> -	struct drm_modeset_acquire_ctx ctx;
>  
>  	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] force=%d\n",
>  		      connector->base.id, connector->name,
> @@ -721,10 +722,9 @@ intel_crt_detect(struct drm_connector *connector, bool force)
>  		goto out;
>  	}
>  
> -	drm_modeset_acquire_init(&ctx, 0);
> -
>  	/* for pre-945g platforms use load detect */
> -	if (intel_get_load_detect_pipe(connector, NULL, &tmp, &ctx)) {
> +	ret = intel_get_load_detect_pipe(connector, NULL, &tmp, ctx);
> +	if (ret > 0) {
>  		if (intel_crt_detect_ddc(connector))
>  			status = connector_status_connected;
>  		else if (INTEL_GEN(dev_priv) < 4)
> @@ -734,12 +734,11 @@ intel_crt_detect(struct drm_connector *connector, bool force)
>  			status = connector_status_disconnected;
>  		else
>  			status = connector_status_unknown;
> -		intel_release_load_detect_pipe(connector, &tmp, &ctx);
> -	} else
> +		intel_release_load_detect_pipe(connector, &tmp, ctx);
> +	} else if (ret == 0)
>  		status = connector_status_unknown;
> -
> -	drm_modeset_drop_locks(&ctx);
> -	drm_modeset_acquire_fini(&ctx);
> +	else if (ret < 0)
> +		status = ret;
>  
>  out:
>  	intel_display_power_put(dev_priv, intel_encoder->power_domain);
> @@ -811,7 +810,6 @@ void intel_crt_reset(struct drm_encoder *encoder)
>  
>  static const struct drm_connector_funcs intel_crt_connector_funcs = {
>  	.dpms = drm_atomic_helper_connector_dpms,
> -	.detect = intel_crt_detect,
>  	.fill_modes = drm_helper_probe_single_connector_modes,
>  	.late_register = intel_connector_register,
>  	.early_unregister = intel_connector_unregister,
> @@ -823,6 +821,7 @@ static const struct drm_connector_funcs intel_crt_connector_funcs = {
>  };
>  
>  static const struct drm_connector_helper_funcs intel_crt_connector_helper_funcs = {
> +	.detect_ctx = intel_crt_detect,
>  	.mode_valid = intel_crt_mode_valid,
>  	.get_modes = intel_crt_get_modes,
>  };
> diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
> index bf81afe2748c..a76a8b040ccf 100644
> --- a/drivers/gpu/drm/i915/intel_display.c
> +++ b/drivers/gpu/drm/i915/intel_display.c
> @@ -9503,10 +9503,10 @@ static int intel_modeset_setup_plane_state(struct drm_atomic_state *state,
>  	return 0;
>  }
>  
> -bool intel_get_load_detect_pipe(struct drm_connector *connector,
> -				struct drm_display_mode *mode,
> -				struct intel_load_detect_pipe *old,
> -				struct drm_modeset_acquire_ctx *ctx)
> +int intel_get_load_detect_pipe(struct drm_connector *connector,
> +			       struct drm_display_mode *mode,
> +			       struct intel_load_detect_pipe *old,
> +			       struct drm_modeset_acquire_ctx *ctx)
>  {
>  	struct intel_crtc *intel_crtc;
>  	struct intel_encoder *intel_encoder =
> @@ -9529,10 +9529,7 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
>  
>  	old->restore_state = NULL;
>  
> -retry:
> -	ret = drm_modeset_lock(&config->connection_mutex, ctx);
> -	if (ret)
> -		goto fail;
> +	WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
>  
>  	/*
>  	 * Algorithm gets a little messy:
> @@ -9682,10 +9679,8 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
>  		restore_state = NULL;
>  	}
>  
> -	if (ret == -EDEADLK) {
> -		drm_modeset_backoff(ctx);
> -		goto retry;
> -	}
> +	if (ret == -EDEADLK)
> +		return ret;
>  
>  	return false;
>  }
> @@ -15116,6 +15111,7 @@ static void intel_enable_pipe_a(struct drm_device *dev)
>  	struct drm_connector *crt = NULL;
>  	struct intel_load_detect_pipe load_detect_temp;
>  	struct drm_modeset_acquire_ctx *ctx = dev->mode_config.acquire_ctx;
> +	int ret;
>  
>  	/* We can't just switch on the pipe A, we need to set things up with a
>  	 * proper mode and output configuration. As a gross hack, enable pipe A
> @@ -15132,7 +15128,10 @@ static void intel_enable_pipe_a(struct drm_device *dev)
>  	if (!crt)
>  		return;
>  
> -	if (intel_get_load_detect_pipe(crt, NULL, &load_detect_temp, ctx))
> +	ret = intel_get_load_detect_pipe(crt, NULL, &load_detect_temp, ctx);
> +	WARN(ret < 0, "All modeset mutexes are locked, but intel_get_load_detect_pipe failed\n");
> +
> +	if (ret > 0)
>  		intel_release_load_detect_pipe(crt, &load_detect_temp, ctx);
>  }
>  
> diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
> index fd96a6cf7326..68896d4742cb 100644
> --- a/drivers/gpu/drm/i915/intel_dp.c
> +++ b/drivers/gpu/drm/i915/intel_dp.c
> @@ -4566,8 +4566,9 @@ intel_dp_unset_edid(struct intel_dp *intel_dp)
>  	intel_dp->has_audio = false;
>  }
>  
> -static enum drm_connector_status
> -intel_dp_long_pulse(struct intel_connector *intel_connector)
> +static int
> +intel_dp_long_pulse(struct intel_connector *intel_connector,
> +		    struct drm_modeset_acquire_ctx *ctx)

We don't really seem to need the ctx, but no harm in wiring this up
either.

>  {
>  	struct drm_connector *connector = &intel_connector->base;
>  	struct intel_dp *intel_dp = intel_attached_dp(connector);
> @@ -4635,14 +4636,7 @@ intel_dp_long_pulse(struct intel_connector *intel_connector)
>  		status = connector_status_disconnected;
>  		goto out;
>  	} else if (connector->status == connector_status_connected) {
> -		/*
> -		 * If display was connected already and is still connected
> -		 * check links status, there has been known issues of
> -		 * link loss triggerring long pulse!!!!
> -		 */
> -		drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);

WARN_ON(!modeset_locked) would be good here instead. Just in case we
refactor and move this into e.g. the hpd handler.

>  		intel_dp_check_link_status(intel_dp);
> -		drm_modeset_unlock(&dev->mode_config.connection_mutex);
>  		goto out;
>  	}
>  
> @@ -4682,18 +4676,20 @@ intel_dp_long_pulse(struct intel_connector *intel_connector)
>  	return status;
>  }
>  
> -static enum drm_connector_status
> -intel_dp_detect(struct drm_connector *connector, bool force)
> +static int
> +intel_dp_detect(struct drm_connector *connector,
> +		struct drm_modeset_acquire_ctx *ctx,
> +		bool force)
>  {
>  	struct intel_dp *intel_dp = intel_attached_dp(connector);
> -	enum drm_connector_status status = connector->status;
> +	int status = connector->status;
>  
>  	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
>  		      connector->base.id, connector->name);
>  
>  	/* If full detect is not performed yet, do a full detect */
>  	if (!intel_dp->detect_done)
> -		status = intel_dp_long_pulse(intel_dp->attached_connector);
> +		status = intel_dp_long_pulse(intel_dp->attached_connector, ctx);
>  
>  	intel_dp->detect_done = false;
>  
> @@ -5014,7 +5010,6 @@ void intel_dp_encoder_reset(struct drm_encoder *encoder)
>  
>  static const struct drm_connector_funcs intel_dp_connector_funcs = {
>  	.dpms = drm_atomic_helper_connector_dpms,
> -	.detect = intel_dp_detect,
>  	.force = intel_dp_force,
>  	.fill_modes = drm_helper_probe_single_connector_modes,
>  	.set_property = intel_dp_set_property,
> @@ -5027,6 +5022,7 @@ static const struct drm_connector_funcs intel_dp_connector_funcs = {
>  };
>  
>  static const struct drm_connector_helper_funcs intel_dp_connector_helper_funcs = {
> +	.detect_ctx = intel_dp_detect,
>  	.get_modes = intel_dp_get_modes,
>  	.mode_valid = intel_dp_mode_valid,
>  };
> diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
> index 313fad059bfa..aaee3949a422 100644
> --- a/drivers/gpu/drm/i915/intel_drv.h
> +++ b/drivers/gpu/drm/i915/intel_drv.h
> @@ -1358,10 +1358,10 @@ int ironlake_get_lanes_required(int target_clock, int link_bw, int bpp);
>  void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
>  			 struct intel_digital_port *dport,
>  			 unsigned int expected_mask);
> -bool intel_get_load_detect_pipe(struct drm_connector *connector,
> -				struct drm_display_mode *mode,
> -				struct intel_load_detect_pipe *old,
> -				struct drm_modeset_acquire_ctx *ctx);
> +int intel_get_load_detect_pipe(struct drm_connector *connector,
> +			       struct drm_display_mode *mode,
> +			       struct intel_load_detect_pipe *old,
> +			       struct drm_modeset_acquire_ctx *ctx);
>  void intel_release_load_detect_pipe(struct drm_connector *connector,
>  				    struct intel_load_detect_pipe *old,
>  				    struct drm_modeset_acquire_ctx *ctx);
> diff --git a/drivers/gpu/drm/i915/intel_hotplug.c b/drivers/gpu/drm/i915/intel_hotplug.c
> index 7d210097eefa..f1200272a699 100644
> --- a/drivers/gpu/drm/i915/intel_hotplug.c
> +++ b/drivers/gpu/drm/i915/intel_hotplug.c
> @@ -243,7 +243,8 @@ static bool intel_hpd_irq_event(struct drm_device *dev,
>  	WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
>  	old_status = connector->status;
>  
> -	connector->status = connector->funcs->detect(connector, false);
> +	connector->status = drm_helper_probe_detect(connector, NULL, false);
> +
>  	if (old_status == connector->status)
>  		return false;
>  
> diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
> index 6ed1a3ce47b7..e077c2a9e694 100644
> --- a/drivers/gpu/drm/i915/intel_tv.c
> +++ b/drivers/gpu/drm/i915/intel_tv.c
> @@ -1315,8 +1315,10 @@ static void intel_tv_find_better_format(struct drm_connector *connector)
>   * Currently this always returns CONNECTOR_STATUS_UNKNOWN, as we need to be sure
>   * we have a pipe programmed in order to probe the TV.
>   */
> -static enum drm_connector_status
> -intel_tv_detect(struct drm_connector *connector, bool force)
> +static int
> +intel_tv_detect(struct drm_connector *connector,
> +		struct drm_modeset_acquire_ctx *ctx,
> +		bool force)
>  {
>  	struct drm_display_mode mode;
>  	struct intel_tv *intel_tv = intel_attached_tv(connector);
> @@ -1331,21 +1333,20 @@ intel_tv_detect(struct drm_connector *connector, bool force)
>  
>  	if (force) {
>  		struct intel_load_detect_pipe tmp;
> -		struct drm_modeset_acquire_ctx ctx;
> +		int ret;
>  
> -		drm_modeset_acquire_init(&ctx, 0);
> +		ret = intel_get_load_detect_pipe(connector, &mode, &tmp, ctx);
> +		if (ret < 0)
> +			return ret;
>  
> -		if (intel_get_load_detect_pipe(connector, &mode, &tmp, &ctx)) {
> +		if (ret > 0) {
>  			type = intel_tv_detect_type(intel_tv, connector);
> -			intel_release_load_detect_pipe(connector, &tmp, &ctx);
> +			intel_release_load_detect_pipe(connector, &tmp, ctx);
>  			status = type < 0 ?
>  				connector_status_disconnected :
>  				connector_status_connected;
>  		} else
>  			status = connector_status_unknown;
> -
> -		drm_modeset_drop_locks(&ctx);
> -		drm_modeset_acquire_fini(&ctx);
>  	} else
>  		return connector->status;
>  
> @@ -1516,7 +1517,6 @@ intel_tv_set_property(struct drm_connector *connector, struct drm_property *prop
>  
>  static const struct drm_connector_funcs intel_tv_connector_funcs = {
>  	.dpms = drm_atomic_helper_connector_dpms,
> -	.detect = intel_tv_detect,
>  	.late_register = intel_connector_register,
>  	.early_unregister = intel_connector_unregister,
>  	.destroy = intel_tv_destroy,
> @@ -1528,6 +1528,7 @@ static const struct drm_connector_funcs intel_tv_connector_funcs = {
>  };
>  
>  static const struct drm_connector_helper_funcs intel_tv_connector_helper_funcs = {
> +	.detect_ctx = intel_tv_detect,
>  	.mode_valid = intel_tv_mode_valid,
>  	.get_modes = intel_tv_get_modes,
>  };
> diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h
> index 941f57f311aa..8d36ab2b1666 100644
> --- a/include/drm/drm_connector.h
> +++ b/include/drm/drm_connector.h
> @@ -32,6 +32,7 @@
>  struct drm_device;
>  
>  struct drm_connector_helper_funcs;
> +struct drm_modeset_acquire_ctx;
>  struct drm_device;
>  struct drm_crtc;
>  struct drm_encoder;
> @@ -378,6 +379,10 @@ struct drm_connector_funcs {
>  	 * the helper library vtable purely for historical reasons. The only DRM
>  	 * core	entry point to probe connector state is @fill_modes.
>  	 *
> +	 * Atomic drivers that might have state that shouldn't race against
> +	 * atomic_check must use &drm_connector_helper_funcs.detect_ctx
> +	 * instead.

Nah, we already hold the lock. Instead:

"Note that the helper library will already hold
@drm_mode_config.connection_mutex. Drivers which need to grab additional
locks to avoid races with concurrent modeset changes need to instead use
&drm_connector_helper_funcs.detect.ctx."

Also, this patch changes the samantics for @force and @get_modes. Please
add there a new para to explain this, e.g.

"To avoid races with concurrent modeset changes the helper libraries
always call this with the &drm_mode_config.connection_mutex held."

Also, it would be good if we could smash some more WARN_ON(!locked) over
our get_modes functions, to make sure this won't break. We can do that
later on in the follow-up patch series to fix up all the i915 connector
state though.

> +	 *
>  	 * RETURNS:
>  	 *
>  	 * drm_connector_status indicating the connector's status.
> diff --git a/include/drm/drm_crtc_helper.h b/include/drm/drm_crtc_helper.h
> index 43505c7b2b3f..76e237bd989b 100644
> --- a/include/drm/drm_crtc_helper.h
> +++ b/include/drm/drm_crtc_helper.h
> @@ -67,6 +67,9 @@ int drm_helper_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
>  int drm_helper_probe_single_connector_modes(struct drm_connector
>  					    *connector, uint32_t maxX,
>  					    uint32_t maxY);
> +int drm_helper_probe_detect(struct drm_connector *connector,
> +			    struct drm_modeset_acquire_ctx *ctx,
> +			    bool force);
>  void drm_kms_helper_poll_init(struct drm_device *dev);
>  void drm_kms_helper_poll_fini(struct drm_device *dev);
>  bool drm_helper_hpd_irq_event(struct drm_device *dev);
> diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h
> index 091c42205667..b304950b402d 100644
> --- a/include/drm/drm_modeset_helper_vtables.h
> +++ b/include/drm/drm_modeset_helper_vtables.h
> @@ -754,6 +754,30 @@ struct drm_connector_helper_funcs {
>  	int (*get_modes)(struct drm_connector *connector);
>  
>  	/**
> +	 * @detect_ctx:
> +	 *
> +	 * Check to see if anything is attached to the connector. The parameter
> +	 * force is set to false whilst polling, true when checking the
> +	 * connector due to a user request. force can be used by the driver to
> +	 * avoid expensive, destructive operations during automated probing.
> +	 *
> +	 * This callback is optional, if not implemented the connector will be
> +	 * considered as always being attached.
> +	 *
> +	 * This is the atomic version of &drm_connector_funcs.detect.
> +	 *
> +	 * ctx is always set, and connection_mutex is always locked.

&drm_mode_config.connection_mutex

> +	 *
> +	 * RETURNS:
> +	 *
> +	 * drm_connector_status indicating the connector's status,

&enum drm_connector_status

> +	 * or the error code returned by drm_modeset_lock (-EDEADLK).

drm_modeset_lock()

Please build docs to double-check all the links work and point in the
right direction :-)

> +	 */
> +	int (*detect_ctx)(struct drm_connector *connector,
> +			  struct drm_modeset_acquire_ctx *ctx,
> +			  bool force);
> +
> +	/**
>  	 * @mode_valid:
>  	 *
>  	 * Callback to validate a mode for a connector, irrespective of the
> -- 
> 2.7.4
> 
> 

-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch


More information about the Intel-gfx mailing list