[v7,07/54] drm/bridge: Add connector-related bridge operations and data

Commit Message

Laurent Pinchart Feb. 22, 2020, 3 p.m. UTC

To support implementation of DRM connectors on top of DRM bridges
instead of by bridges, the drm_bridge needs to expose new operations and
data:

- Output detection, hot-plug notification, mode retrieval and EDID
  retrieval operations
- Bitmask of supported operations
- Bridge output type
- I2C adapter for DDC access

Add and document these.

Three new bridge helper functions are also added to handle hot plug
notification in a way that is as transparent as possible for the
bridges.

Signed-off-by: Laurent Pinchart <[e-mail]>
Reviewed-by: Boris Brezillon <[e-mail]>
Reviewed-by: Sam Ravnborg <[e-mail]>
Tested-by: Sebastian Reichel <[e-mail]>
Reviewed-by: Sebastian Reichel <[e-mail]>
---
Changes since v6:

- Don't check for NULL bridge in drm_bridge_hpd_enable() and
  drm_bridge_hpd_disable()

Changes since v3:

- Fix typos

Changes since v2:

- Add wrappers around the .detect(), .get_modes() and .get_edid()
  operations
- Warn bridge drivers about valid usage of the connector argument to
  .get_modes() and .get_edid()

Changes since v1:

- Make .hpd_enable() and .hpd_disable() optional
- Rename .lost_hotplug() to .hpd_notify()
- Add ddc field to drm_bridge
---
 drivers/gpu/drm/drm_bridge.c | 201 ++++++++++++++++++++++++++++++++++-
 include/drm/drm_bridge.h     | 192 ++++++++++++++++++++++++++++++++-
 2 files changed, 391 insertions(+), 2 deletions(-)

Comments

Daniel Vetter Feb. 22, 2020, 3:34 p.m. UTC | #1

On Sat, Feb 22, 2020 at 4:01 PM Laurent Pinchart
<[e-mail]> wrote:
>
> To support implementation of DRM connectors on top of DRM bridges
> instead of by bridges, the drm_bridge needs to expose new operations and
> data:
>
> - Output detection, hot-plug notification, mode retrieval and EDID
>   retrieval operations
> - Bitmask of supported operations
> - Bridge output type
> - I2C adapter for DDC access
>
> Add and document these.
>
> Three new bridge helper functions are also added to handle hot plug
> notification in a way that is as transparent as possible for the
> bridges.
>
> Signed-off-by: Laurent Pinchart <[e-mail]>
> Reviewed-by: Boris Brezillon <[e-mail]>
> Reviewed-by: Sam Ravnborg <[e-mail]>
> Tested-by: Sebastian Reichel <[e-mail]>
> Reviewed-by: Sebastian Reichel <[e-mail]>
> ---
> Changes since v6:
>
> - Don't check for NULL bridge in drm_bridge_hpd_enable() and
>   drm_bridge_hpd_disable()
>
> Changes since v3:
>
> - Fix typos
>
> Changes since v2:
>
> - Add wrappers around the .detect(), .get_modes() and .get_edid()
>   operations
> - Warn bridge drivers about valid usage of the connector argument to
>   .get_modes() and .get_edid()
>
> Changes since v1:
>
> - Make .hpd_enable() and .hpd_disable() optional
> - Rename .lost_hotplug() to .hpd_notify()
> - Add ddc field to drm_bridge
> ---
>  drivers/gpu/drm/drm_bridge.c | 201 ++++++++++++++++++++++++++++++++++-
>  include/drm/drm_bridge.h     | 192 ++++++++++++++++++++++++++++++++-
>  2 files changed, 391 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c
> index 5f55a9e17a7c..d236984a963e 100644
> --- a/drivers/gpu/drm/drm_bridge.c
> +++ b/drivers/gpu/drm/drm_bridge.c
> @@ -82,6 +82,8 @@ static LIST_HEAD(bridge_list);
>   */
>  void drm_bridge_add(struct drm_bridge *bridge)
>  {
> +       mutex_init(&bridge->hpd_mutex);
> +
>         mutex_lock(&bridge_lock);
>         list_add_tail(&bridge->list, &bridge_list);
>         mutex_unlock(&bridge_lock);
> @@ -98,6 +100,8 @@ void drm_bridge_remove(struct drm_bridge *bridge)
>         mutex_lock(&bridge_lock);
>         list_del_init(&bridge->list);
>         mutex_unlock(&bridge_lock);
> +
> +       mutex_destroy(&bridge->hpd_mutex);
>  }
>  EXPORT_SYMBOL(drm_bridge_remove);
>
> @@ -228,7 +232,7 @@ void drm_bridge_detach(struct drm_bridge *bridge)
>   * Bridge drivers expose operations through the &drm_bridge_funcs structure.
>   * The DRM internals (atomic and CRTC helpers) use the helpers defined in
>   * drm_bridge.c to call bridge operations. Those operations are divided in
> - * two big categories to support different parts of the bridge usage.
> + * three big categories to support different parts of the bridge usage.
>   *
>   * - The encoder-related operations support control of the bridges in the
>   *   chain, and are roughly counterparts to the &drm_encoder_helper_funcs
> @@ -258,6 +262,43 @@ void drm_bridge_detach(struct drm_bridge *bridge)
>   *   implement them shall thus also implement the atomic version of the
>   *   encoder-related operations. This feature is not supported by the legacy
>   *   CRTC helpers.
> + *
> + * - The connector-related operations support implementing a &drm_connector
> + *   based on a chain of bridges. DRM bridges traditionally create a
> + *   &drm_connector for bridges meant to be used at the end of the chain. This
> + *   puts additional burden on bridge drivers, especially for bridges that may
> + *   be used in the middle of a chain or at the end of it. Furthermore, it
> + *   requires all operations of the &drm_connector to be handled by a single
> + *   bridge, which doesn't always match the hardware architecture.
> + *
> + *   To simplify bridge drivers and make the connector implementation more
> + *   flexible, a new model allows bridges to unconditionally skip creation of
> + *   &drm_connector and instead expose &drm_bridge_funcs operations to support
> + *   an externally-implemented &drm_connector. Those operations are
> + *   &drm_bridge_funcs.detect, &drm_bridge_funcs.get_modes,
> + *   &drm_bridge_funcs.get_edid, &drm_bridge_funcs.hpd_notify,
> + *   &drm_bridge_funcs.hpd_enable and &drm_bridge_funcs.hpd_disable. When
> + *   implemented, display drivers shall create a &drm_connector instance for
> + *   each chain of bridges, and implement those connector instances based on
> + *   the bridge connector operations.
> + *
> + *   Bridge drivers shall implement the connector-related operations for all
> + *   the features that the bridge hardware support. For instance, if a bridge
> + *   supports reading EDID, the &drm_bridge_funcs.get_edid shall be
> + *   implemented. This however doesn't mean that the DDC lines are wired to the
> + *   bridge on a particular platform, as they could also be connected to an I2C
> + *   controller of the SoC. Support for the connector-related operations on the
> + *   running platform is reported through the &drm_bridge.ops flags. Bridge
> + *   drivers shall detect which operations they can support on the platform
> + *   (usually this information is provided by ACPI or DT), and set the
> + *   &drm_bridge.ops flags for all supported operations. A flag shall only be
> + *   set if the corresponding &drm_bridge_funcs operation is implemented, but
> + *   an implemented operation doesn't necessarily imply that the corresponding
> + *   flag will be set. Display drivers shall use the &drm_bridge.ops flags to
> + *   decide which bridge to delegate a connector operation to. This mechanism
> + *   allows providing a single static const &drm_bridge_funcs instance in
> + *   bridge drivers, improving security by storing function pointers in
> + *   read-only memory.

Good enough that even dense me gets this now!

Acked-by: Daniel Vetter <[e-mail]>

>   */
>
>  /**
> @@ -957,6 +998,164 @@ int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,
>  }
>  EXPORT_SYMBOL(drm_atomic_bridge_chain_check);
>
> +/**
> + * drm_bridge_detect - check if anything is attached to the bridge output
> + * @bridge: bridge control structure
> + *
> + * If the bridge supports output detection, as reported by the
> + * DRM_BRIDGE_OP_DETECT bridge ops flag, call &drm_bridge_funcs.detect for the
> + * bridge and return the connection status. Otherwise return
> + * connector_status_unknown.
> + *
> + * RETURNS:
> + * The detection status on success, or connector_status_unknown if the bridge
> + * doesn't support output detection.
> + */
> +enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge)
> +{
> +       if (!(bridge->ops & DRM_BRIDGE_OP_DETECT))
> +               return connector_status_unknown;
> +
> +       return bridge->funcs->detect(bridge);
> +}
> +EXPORT_SYMBOL_GPL(drm_bridge_detect);
> +
> +/**
> + * drm_bridge_get_modes - fill all modes currently valid for the sink into the
> + * @connector
> + * @bridge: bridge control structure
> + * @connector: the connector to fill with modes
> + *
> + * If the bridge supports output modes retrieval, as reported by the
> + * DRM_BRIDGE_OP_MODES bridge ops flag, call &drm_bridge_funcs.get_modes to
> + * fill the connector with all valid modes and return the number of modes
> + * added. Otherwise return 0.
> + *
> + * RETURNS:
> + * The number of modes added to the connector.
> + */
> +int drm_bridge_get_modes(struct drm_bridge *bridge,
> +                        struct drm_connector *connector)
> +{
> +       if (!(bridge->ops & DRM_BRIDGE_OP_MODES))
> +               return 0;
> +
> +       return bridge->funcs->get_modes(bridge, connector);
> +}
> +EXPORT_SYMBOL_GPL(drm_bridge_get_modes);
> +
> +/**
> + * drm_bridge_get_edid - get the EDID data of the connected display
> + * @bridge: bridge control structure
> + * @connector: the connector to read EDID for
> + *
> + * If the bridge supports output EDID retrieval, as reported by the
> + * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.get_edid to
> + * get the EDID and return it. Otherwise return ERR_PTR(-ENOTSUPP).
> + *
> + * RETURNS:
> + * The retrieved EDID on success, or an error pointer otherwise.
> + */
> +struct edid *drm_bridge_get_edid(struct drm_bridge *bridge,
> +                                struct drm_connector *connector)
> +{
> +       if (!(bridge->ops & DRM_BRIDGE_OP_EDID))
> +               return ERR_PTR(-ENOTSUPP);
> +
> +       return bridge->funcs->get_edid(bridge, connector);
> +}
> +EXPORT_SYMBOL_GPL(drm_bridge_get_edid);
> +
> +/**
> + * drm_bridge_hpd_enable - enable hot plug detection for the bridge
> + * @bridge: bridge control structure
> + * @cb: hot-plug detection callback
> + * @data: data to be passed to the hot-plug detection callback
> + *
> + * Call &drm_bridge_funcs.hpd_enable if implemented and register the given @cb
> + * and @data as hot plug notification callback. From now on the @cb will be
> + * called with @data when an output status change is detected by the bridge,
> + * until hot plug notification gets disabled with drm_bridge_hpd_disable().
> + *
> + * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in
> + * bridge->ops. This function shall not be called when the flag is not set.
> + *
> + * Only one hot plug detection callback can be registered at a time, it is an
> + * error to call this function when hot plug detection is already enabled for
> + * the bridge.
> + */
> +void drm_bridge_hpd_enable(struct drm_bridge *bridge,
> +                          void (*cb)(void *data,
> +                                     enum drm_connector_status status),
> +                          void *data)
> +{
> +       if (!(bridge->ops & DRM_BRIDGE_OP_HPD))
> +               return;
> +
> +       mutex_lock(&bridge->hpd_mutex);
> +
> +       if (WARN(bridge->hpd_cb, "Hot plug detection already enabled\n"))
> +               goto unlock;
> +
> +       bridge->hpd_cb = cb;
> +       bridge->hpd_data = data;
> +
> +       if (bridge->funcs->hpd_enable)
> +               bridge->funcs->hpd_enable(bridge);
> +
> +unlock:
> +       mutex_unlock(&bridge->hpd_mutex);
> +}
> +EXPORT_SYMBOL_GPL(drm_bridge_hpd_enable);
> +
> +/**
> + * drm_bridge_hpd_disable - disable hot plug detection for the bridge
> + * @bridge: bridge control structure
> + *
> + * Call &drm_bridge_funcs.hpd_disable if implemented and unregister the hot
> + * plug detection callback previously registered with drm_bridge_hpd_enable().
> + * Once this function returns the callback will not be called by the bridge
> + * when an output status change occurs.
> + *
> + * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in
> + * bridge->ops. This function shall not be called when the flag is not set.
> + */
> +void drm_bridge_hpd_disable(struct drm_bridge *bridge)
> +{
> +       if (!(bridge->ops & DRM_BRIDGE_OP_HPD))
> +               return;
> +
> +       mutex_lock(&bridge->hpd_mutex);
> +       if (bridge->funcs->hpd_disable)
> +               bridge->funcs->hpd_disable(bridge);
> +
> +       bridge->hpd_cb = NULL;
> +       bridge->hpd_data = NULL;
> +       mutex_unlock(&bridge->hpd_mutex);
> +}
> +EXPORT_SYMBOL_GPL(drm_bridge_hpd_disable);
> +
> +/**
> + * drm_bridge_hpd_notify - notify hot plug detection events
> + * @bridge: bridge control structure
> + * @status: output connection status
> + *
> + * Bridge drivers shall call this function to report hot plug events when they
> + * detect a change in the output status, when hot plug detection has been
> + * enabled by drm_bridge_hpd_enable().
> + *
> + * This function shall be called in a context that can sleep.
> + */
> +void drm_bridge_hpd_notify(struct drm_bridge *bridge,
> +                          enum drm_connector_status status)
> +{
> +       mutex_lock(&bridge->hpd_mutex);
> +       if (bridge->hpd_cb)
> +               bridge->hpd_cb(bridge->hpd_data, status);
> +       mutex_unlock(&bridge->hpd_mutex);
> +}
> +EXPORT_SYMBOL_GPL(drm_bridge_hpd_notify);
> +
>  #ifdef CONFIG_OF
>  /**
>   * of_drm_find_bridge - find the bridge corresponding to the device node in
> diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h
> index 38de129d5947..9d5d750973e9 100644
> --- a/include/drm/drm_bridge.h
> +++ b/include/drm/drm_bridge.h
> @@ -23,8 +23,9 @@
>  #ifndef __DRM_BRIDGE_H__
>  #define __DRM_BRIDGE_H__
>
> -#include <linux/list.h>
>  #include <linux/ctype.h>
> +#include <linux/list.h>
> +#include <linux/mutex.h>
>
>  #include <drm/drm_atomic.h>
>  #include <drm/drm_encoder.h>
> @@ -33,7 +34,10 @@
>
>  struct drm_bridge;
>  struct drm_bridge_timings;
> +struct drm_connector;
>  struct drm_panel;
> +struct edid;
> +struct i2c_adapter;
>
>  /**
>   * struct drm_bridge_funcs - drm_bridge control functions
> @@ -497,6 +501,119 @@ struct drm_bridge_funcs {
>          * giving the reason of the failure otherwise.
>          */
>         struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge);
> +
> +       /**
> +        * @detect:
> +        *
> +        * Check if anything is attached to the bridge output.
> +        *
> +        * This callback is optional, if not implemented the bridge will be
> +        * considered as always having a component attached to its output.
> +        * Bridges that implement this callback shall set the
> +        * DRM_BRIDGE_OP_DETECT flag in their &drm_bridge->ops.
> +        *
> +        * RETURNS:
> +        *
> +        * drm_connector_status indicating the bridge output status.
> +        */
> +       enum drm_connector_status (*detect)(struct drm_bridge *bridge);
> +
> +       /**
> +        * @get_modes:
> +        *
> +        * Fill all modes currently valid for the sink into the &drm_connector
> +        * with drm_mode_probed_add().
> +        *
> +        * The @get_modes callback is mostly intended to support non-probeable
> +        * displays such as many fixed panels. Bridges that support reading
> +        * EDID shall leave @get_modes unimplemented and implement the
> +        * &drm_bridge_funcs->get_edid callback instead.
> +        *
> +        * This callback is optional. Bridges that implement it shall set the
> +        * DRM_BRIDGE_OP_MODES flag in their &drm_bridge->ops.
> +        *
> +        * The connector parameter shall be used for the sole purpose of
> +        * filling modes, and shall not be stored internally by bridge drivers
> +        * for future usage.
> +        *
> +        * RETURNS:
> +        *
> +        * The number of modes added by calling drm_mode_probed_add().
> +        */
> +       int (*get_modes)(struct drm_bridge *bridge,
> +                        struct drm_connector *connector);
> +
> +       /**
> +        * @get_edid:
> +        *
> +        * Read and parse the EDID data of the connected display.
> +        *
> +        * The @get_edid callback is the preferred way of reporting mode
> +        * information for a display connected to the bridge output. Bridges
> +        * that support reading EDID shall implement this callback and leave
> +        * the @get_modes callback unimplemented.
> +        *
> +        * The caller of this operation shall first verify the output
> +        * connection status and refrain from reading EDID from a disconnected
> +        * output.
> +        *
> +        * This callback is optional. Bridges that implement it shall set the
> +        * DRM_BRIDGE_OP_EDID flag in their &drm_bridge->ops.
> +        *
> +        * The connector parameter shall be used for the sole purpose of EDID
> +        * retrieval and parsing, and shall not be stored internally by bridge
> +        * drivers for future usage.
> +        *
> +        * RETURNS:
> +        *
> +        * An edid structure newly allocated with kmalloc() (or similar) on
> +        * success, or NULL otherwise. The caller is responsible for freeing
> +        * the returned edid structure with kfree().
> +        */
> +       struct edid *(*get_edid)(struct drm_bridge *bridge,
> +                                struct drm_connector *connector);
> +
> +       /**
> +        * @hpd_notify:
> +        *
> +        * Notify the bridge of hot plug detection.
> +        *
> +        * This callback is optional, it may be implemented by bridges that
> +        * need to be notified of display connection or disconnection for
> +        * internal reasons. One use case is to reset the internal state of CEC
> +        * controllers for HDMI bridges.
> +        */
> +       void (*hpd_notify)(struct drm_bridge *bridge,
> +                          enum drm_connector_status status);
> +
> +       /**
> +        * @hpd_enable:
> +        *
> +        * Enable hot plug detection. From now on the bridge shall call
> +        * drm_bridge_hpd_notify() each time a change is detected in the output
> +        * connection status, until hot plug detection gets disabled with
> +        * @hpd_disable.
> +        *
> +        * This callback is optional and shall only be implemented by bridges
> +        * that support hot-plug notification without polling. Bridges that
> +        * implement it shall also implement the @hpd_disable callback and set
> +        * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops.
> +        */
> +       void (*hpd_enable)(struct drm_bridge *bridge);
> +
> +       /**
> +        * @hpd_disable:
> +        *
> +        * Disable hot plug detection. Once this function returns the bridge
> +        * shall not call drm_bridge_hpd_notify() when a change in the output
> +        * connection status occurs.
> +        *
> +        * This callback is optional and shall only be implemented by bridges
> +        * that support hot-plug notification without polling. Bridges that
> +        * implement it shall also implement the @hpd_enable callback and set
> +        * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops.
> +        */
> +       void (*hpd_disable)(struct drm_bridge *bridge);
>  };
>
>  /**
> @@ -535,6 +652,39 @@ struct drm_bridge_timings {
>         bool dual_link;
>  };
>
> +/**
> + * enum drm_bridge_ops - Bitmask of operations supported by the bridge
> + */
> +enum drm_bridge_ops {
> +       /**
> +        * @DRM_BRIDGE_OP_DETECT: The bridge can detect displays connected to
> +        * its output. Bridges that set this flag shall implement the
> +        * &drm_bridge_funcs->detect callback.
> +        */
> +       DRM_BRIDGE_OP_DETECT = BIT(0),
> +       /**
> +        * @DRM_BRIDGE_OP_EDID: The bridge can retrieve the EDID of the display
> +        * connected to its output. Bridges that set this flag shall implement
> +        * the &drm_bridge_funcs->get_edid callback.
> +        */
> +       DRM_BRIDGE_OP_EDID = BIT(1),
> +       /**
> +        * @DRM_BRIDGE_OP_HPD: The bridge can detect hot-plug and hot-unplug
> +        * without requiring polling. Bridges that set this flag shall
> +        * implement the &drm_bridge_funcs->hpd_enable and
> +        * &drm_bridge_funcs->hpd_disable callbacks if they support enabling
> +        * and disabling hot-plug detection dynamically.
> +        */
> +       DRM_BRIDGE_OP_HPD = BIT(2),
> +       /**
> +        * @DRM_BRIDGE_OP_MODES: The bridge can retrieve the modes supported
> +        * by the display at its output. This does not include reading EDID
> +        * which is separately covered by @DRM_BRIDGE_OP_EDID. Bridges that set
> +        * this flag shall implement the &drm_bridge_funcs->get_modes callback.
> +        */
> +       DRM_BRIDGE_OP_MODES = BIT(3),
> +};
> +
>  /**
>   * struct drm_bridge - central DRM bridge control structure
>   */
> @@ -563,6 +713,33 @@ struct drm_bridge {
>         const struct drm_bridge_funcs *funcs;
>         /** @driver_private: pointer to the bridge driver's internal context */
>         void *driver_private;
> +       /** @ops: bitmask of operations supported by the bridge */
> +       enum drm_bridge_ops ops;
> +       /**
> +        * @type: Type of the connection at the bridge output
> +        * (DRM_MODE_CONNECTOR_*). For bridges at the end of this chain this
> +        * identifies the type of connected display.
> +        */
> +       int type;
> +       /**
> +        * @ddc: Associated I2C adapter for DDC access, if any.
> +        */
> +       struct i2c_adapter *ddc;
> +       /** private: */
> +       /**
> +        * @hpd_mutex: Protects the @hpd_cb and @hpd_data fields.
> +        */
> +       struct mutex hpd_mutex;
> +       /**
> +        * @hpd_cb: Hot plug detection callback, registered with
> +        * drm_bridge_hpd_enable().
> +        */
> +       void (*hpd_cb)(void *data, enum drm_connector_status status);
> +       /**
> +        * @hpd_data: Private data passed to the Hot plug detection callback
> +        * @hpd_cb.
> +        */
> +       void *hpd_data;
>  };
>
>  static inline struct drm_bridge *
> @@ -669,6 +846,19 @@ drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
>                                         u32 output_fmt,
>                                         unsigned int *num_input_fmts);
>
> +enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge);
> +int drm_bridge_get_modes(struct drm_bridge *bridge,
> +                        struct drm_connector *connector);
> +struct edid *drm_bridge_get_edid(struct drm_bridge *bridge,
> +                                struct drm_connector *connector);
> +void drm_bridge_hpd_enable(struct drm_bridge *bridge,
> +                          void (*cb)(void *data,
> +                                     enum drm_connector_status status),
> +                          void *data);
> +void drm_bridge_hpd_disable(struct drm_bridge *bridge);
> +void drm_bridge_hpd_notify(struct drm_bridge *bridge,
> +                          enum drm_connector_status status);
> +
>  #ifdef CONFIG_DRM_PANEL_BRIDGE
>  struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel);
>  struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel,
> --
> Regards,
>
> Laurent Pinchart
>

Patch

diff --git a/drivers/gpu/drm/drm_bridge.c b/drivers/gpu/drm/drm_bridge.c
index 5f55a9e17a7c..d236984a963e 100644
--- a/drivers/gpu/drm/drm_bridge.c
+++ b/drivers/gpu/drm/drm_bridge.c
@@ -82,6 +82,8 @@  static LIST_HEAD(bridge_list);
  */
 void drm_bridge_add(struct drm_bridge *bridge)
 {
+	mutex_init(&bridge->hpd_mutex);
+
 	mutex_lock(&bridge_lock);
 	list_add_tail(&bridge->list, &bridge_list);
 	mutex_unlock(&bridge_lock);
@@ -98,6 +100,8 @@  void drm_bridge_remove(struct drm_bridge *bridge)
 	mutex_lock(&bridge_lock);
 	list_del_init(&bridge->list);
 	mutex_unlock(&bridge_lock);
+
+	mutex_destroy(&bridge->hpd_mutex);
 }
 EXPORT_SYMBOL(drm_bridge_remove);
 
@@ -228,7 +232,7 @@  void drm_bridge_detach(struct drm_bridge *bridge)
  * Bridge drivers expose operations through the &drm_bridge_funcs structure.
  * The DRM internals (atomic and CRTC helpers) use the helpers defined in
  * drm_bridge.c to call bridge operations. Those operations are divided in
- * two big categories to support different parts of the bridge usage.
+ * three big categories to support different parts of the bridge usage.
  *
  * - The encoder-related operations support control of the bridges in the
  *   chain, and are roughly counterparts to the &drm_encoder_helper_funcs
@@ -258,6 +262,43 @@  void drm_bridge_detach(struct drm_bridge *bridge)
  *   implement them shall thus also implement the atomic version of the
  *   encoder-related operations. This feature is not supported by the legacy
  *   CRTC helpers.
+ *
+ * - The connector-related operations support implementing a &drm_connector
+ *   based on a chain of bridges. DRM bridges traditionally create a
+ *   &drm_connector for bridges meant to be used at the end of the chain. This
+ *   puts additional burden on bridge drivers, especially for bridges that may
+ *   be used in the middle of a chain or at the end of it. Furthermore, it
+ *   requires all operations of the &drm_connector to be handled by a single
+ *   bridge, which doesn't always match the hardware architecture.
+ *
+ *   To simplify bridge drivers and make the connector implementation more
+ *   flexible, a new model allows bridges to unconditionally skip creation of
+ *   &drm_connector and instead expose &drm_bridge_funcs operations to support
+ *   an externally-implemented &drm_connector. Those operations are
+ *   &drm_bridge_funcs.detect, &drm_bridge_funcs.get_modes,
+ *   &drm_bridge_funcs.get_edid, &drm_bridge_funcs.hpd_notify,
+ *   &drm_bridge_funcs.hpd_enable and &drm_bridge_funcs.hpd_disable. When
+ *   implemented, display drivers shall create a &drm_connector instance for
+ *   each chain of bridges, and implement those connector instances based on
+ *   the bridge connector operations.
+ *
+ *   Bridge drivers shall implement the connector-related operations for all
+ *   the features that the bridge hardware support. For instance, if a bridge
+ *   supports reading EDID, the &drm_bridge_funcs.get_edid shall be
+ *   implemented. This however doesn't mean that the DDC lines are wired to the
+ *   bridge on a particular platform, as they could also be connected to an I2C
+ *   controller of the SoC. Support for the connector-related operations on the
+ *   running platform is reported through the &drm_bridge.ops flags. Bridge
+ *   drivers shall detect which operations they can support on the platform
+ *   (usually this information is provided by ACPI or DT), and set the
+ *   &drm_bridge.ops flags for all supported operations. A flag shall only be
+ *   set if the corresponding &drm_bridge_funcs operation is implemented, but
+ *   an implemented operation doesn't necessarily imply that the corresponding
+ *   flag will be set. Display drivers shall use the &drm_bridge.ops flags to
+ *   decide which bridge to delegate a connector operation to. This mechanism
+ *   allows providing a single static const &drm_bridge_funcs instance in
+ *   bridge drivers, improving security by storing function pointers in
+ *   read-only memory.
  */
 
 /**
@@ -957,6 +998,164 @@  int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,
 }
 EXPORT_SYMBOL(drm_atomic_bridge_chain_check);
 
+/**
+ * drm_bridge_detect - check if anything is attached to the bridge output
+ * @bridge: bridge control structure
+ *
+ * If the bridge supports output detection, as reported by the
+ * DRM_BRIDGE_OP_DETECT bridge ops flag, call &drm_bridge_funcs.detect for the
+ * bridge and return the connection status. Otherwise return
+ * connector_status_unknown.
+ *
+ * RETURNS:
+ * The detection status on success, or connector_status_unknown if the bridge
+ * doesn't support output detection.
+ */
+enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge)
+{
+	if (!(bridge->ops & DRM_BRIDGE_OP_DETECT))
+		return connector_status_unknown;
+
+	return bridge->funcs->detect(bridge);
+}
+EXPORT_SYMBOL_GPL(drm_bridge_detect);
+
+/**
+ * drm_bridge_get_modes - fill all modes currently valid for the sink into the
+ * @connector
+ * @bridge: bridge control structure
+ * @connector: the connector to fill with modes
+ *
+ * If the bridge supports output modes retrieval, as reported by the
+ * DRM_BRIDGE_OP_MODES bridge ops flag, call &drm_bridge_funcs.get_modes to
+ * fill the connector with all valid modes and return the number of modes
+ * added. Otherwise return 0.
+ *
+ * RETURNS:
+ * The number of modes added to the connector.
+ */
+int drm_bridge_get_modes(struct drm_bridge *bridge,
+			 struct drm_connector *connector)
+{
+	if (!(bridge->ops & DRM_BRIDGE_OP_MODES))
+		return 0;
+
+	return bridge->funcs->get_modes(bridge, connector);
+}
+EXPORT_SYMBOL_GPL(drm_bridge_get_modes);
+
+/**
+ * drm_bridge_get_edid - get the EDID data of the connected display
+ * @bridge: bridge control structure
+ * @connector: the connector to read EDID for
+ *
+ * If the bridge supports output EDID retrieval, as reported by the
+ * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.get_edid to
+ * get the EDID and return it. Otherwise return ERR_PTR(-ENOTSUPP).
+ *
+ * RETURNS:
+ * The retrieved EDID on success, or an error pointer otherwise.
+ */
+struct edid *drm_bridge_get_edid(struct drm_bridge *bridge,
+				 struct drm_connector *connector)
+{
+	if (!(bridge->ops & DRM_BRIDGE_OP_EDID))
+		return ERR_PTR(-ENOTSUPP);
+
+	return bridge->funcs->get_edid(bridge, connector);
+}
+EXPORT_SYMBOL_GPL(drm_bridge_get_edid);
+
+/**
+ * drm_bridge_hpd_enable - enable hot plug detection for the bridge
+ * @bridge: bridge control structure
+ * @cb: hot-plug detection callback
+ * @data: data to be passed to the hot-plug detection callback
+ *
+ * Call &drm_bridge_funcs.hpd_enable if implemented and register the given @cb
+ * and @data as hot plug notification callback. From now on the @cb will be
+ * called with @data when an output status change is detected by the bridge,
+ * until hot plug notification gets disabled with drm_bridge_hpd_disable().
+ *
+ * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in
+ * bridge->ops. This function shall not be called when the flag is not set.
+ *
+ * Only one hot plug detection callback can be registered at a time, it is an
+ * error to call this function when hot plug detection is already enabled for
+ * the bridge.
+ */
+void drm_bridge_hpd_enable(struct drm_bridge *bridge,
+			   void (*cb)(void *data,
+				      enum drm_connector_status status),
+			   void *data)
+{
+	if (!(bridge->ops & DRM_BRIDGE_OP_HPD))
+		return;
+
+	mutex_lock(&bridge->hpd_mutex);
+
+	if (WARN(bridge->hpd_cb, "Hot plug detection already enabled\n"))
+		goto unlock;
+
+	bridge->hpd_cb = cb;
+	bridge->hpd_data = data;
+
+	if (bridge->funcs->hpd_enable)
+		bridge->funcs->hpd_enable(bridge);
+
+unlock:
+	mutex_unlock(&bridge->hpd_mutex);
+}
+EXPORT_SYMBOL_GPL(drm_bridge_hpd_enable);
+
+/**
+ * drm_bridge_hpd_disable - disable hot plug detection for the bridge
+ * @bridge: bridge control structure
+ *
+ * Call &drm_bridge_funcs.hpd_disable if implemented and unregister the hot
+ * plug detection callback previously registered with drm_bridge_hpd_enable().
+ * Once this function returns the callback will not be called by the bridge
+ * when an output status change occurs.
+ *
+ * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in
+ * bridge->ops. This function shall not be called when the flag is not set.
+ */
+void drm_bridge_hpd_disable(struct drm_bridge *bridge)
+{
+	if (!(bridge->ops & DRM_BRIDGE_OP_HPD))
+		return;
+
+	mutex_lock(&bridge->hpd_mutex);
+	if (bridge->funcs->hpd_disable)
+		bridge->funcs->hpd_disable(bridge);
+
+	bridge->hpd_cb = NULL;
+	bridge->hpd_data = NULL;
+	mutex_unlock(&bridge->hpd_mutex);
+}
+EXPORT_SYMBOL_GPL(drm_bridge_hpd_disable);
+
+/**
+ * drm_bridge_hpd_notify - notify hot plug detection events
+ * @bridge: bridge control structure
+ * @status: output connection status
+ *
+ * Bridge drivers shall call this function to report hot plug events when they
+ * detect a change in the output status, when hot plug detection has been
+ * enabled by drm_bridge_hpd_enable().
+ *
+ * This function shall be called in a context that can sleep.
+ */
+void drm_bridge_hpd_notify(struct drm_bridge *bridge,
+			   enum drm_connector_status status)
+{
+	mutex_lock(&bridge->hpd_mutex);
+	if (bridge->hpd_cb)
+		bridge->hpd_cb(bridge->hpd_data, status);
+	mutex_unlock(&bridge->hpd_mutex);
+}
+EXPORT_SYMBOL_GPL(drm_bridge_hpd_notify);
+
 #ifdef CONFIG_OF
 /**
  * of_drm_find_bridge - find the bridge corresponding to the device node in
diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h
index 38de129d5947..9d5d750973e9 100644
--- a/include/drm/drm_bridge.h
+++ b/include/drm/drm_bridge.h
@@ -23,8 +23,9 @@ 
 #ifndef __DRM_BRIDGE_H__
 #define __DRM_BRIDGE_H__
 
-#include <linux/list.h>
 #include <linux/ctype.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
 
 #include <drm/drm_atomic.h>
 #include <drm/drm_encoder.h>
@@ -33,7 +34,10 @@ 
 
 struct drm_bridge;
 struct drm_bridge_timings;
+struct drm_connector;
 struct drm_panel;
+struct edid;
+struct i2c_adapter;
 
 /**
  * struct drm_bridge_funcs - drm_bridge control functions
@@ -497,6 +501,119 @@  struct drm_bridge_funcs {
 	 * giving the reason of the failure otherwise.
 	 */
 	struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge);
+
+	/**
+	 * @detect:
+	 *
+	 * Check if anything is attached to the bridge output.
+	 *
+	 * This callback is optional, if not implemented the bridge will be
+	 * considered as always having a component attached to its output.
+	 * Bridges that implement this callback shall set the
+	 * DRM_BRIDGE_OP_DETECT flag in their &drm_bridge->ops.
+	 *
+	 * RETURNS:
+	 *
+	 * drm_connector_status indicating the bridge output status.
+	 */
+	enum drm_connector_status (*detect)(struct drm_bridge *bridge);
+
+	/**
+	 * @get_modes:
+	 *
+	 * Fill all modes currently valid for the sink into the &drm_connector
+	 * with drm_mode_probed_add().
+	 *
+	 * The @get_modes callback is mostly intended to support non-probeable
+	 * displays such as many fixed panels. Bridges that support reading
+	 * EDID shall leave @get_modes unimplemented and implement the
+	 * &drm_bridge_funcs->get_edid callback instead.
+	 *
+	 * This callback is optional. Bridges that implement it shall set the
+	 * DRM_BRIDGE_OP_MODES flag in their &drm_bridge->ops.
+	 *
+	 * The connector parameter shall be used for the sole purpose of
+	 * filling modes, and shall not be stored internally by bridge drivers
+	 * for future usage.
+	 *
+	 * RETURNS:
+	 *
+	 * The number of modes added by calling drm_mode_probed_add().
+	 */
+	int (*get_modes)(struct drm_bridge *bridge,
+			 struct drm_connector *connector);
+
+	/**
+	 * @get_edid:
+	 *
+	 * Read and parse the EDID data of the connected display.
+	 *
+	 * The @get_edid callback is the preferred way of reporting mode
+	 * information for a display connected to the bridge output. Bridges
+	 * that support reading EDID shall implement this callback and leave
+	 * the @get_modes callback unimplemented.
+	 *
+	 * The caller of this operation shall first verify the output
+	 * connection status and refrain from reading EDID from a disconnected
+	 * output.
+	 *
+	 * This callback is optional. Bridges that implement it shall set the
+	 * DRM_BRIDGE_OP_EDID flag in their &drm_bridge->ops.
+	 *
+	 * The connector parameter shall be used for the sole purpose of EDID
+	 * retrieval and parsing, and shall not be stored internally by bridge
+	 * drivers for future usage.
+	 *
+	 * RETURNS:
+	 *
+	 * An edid structure newly allocated with kmalloc() (or similar) on
+	 * success, or NULL otherwise. The caller is responsible for freeing
+	 * the returned edid structure with kfree().
+	 */
+	struct edid *(*get_edid)(struct drm_bridge *bridge,
+				 struct drm_connector *connector);
+
+	/**
+	 * @hpd_notify:
+	 *
+	 * Notify the bridge of hot plug detection.
+	 *
+	 * This callback is optional, it may be implemented by bridges that
+	 * need to be notified of display connection or disconnection for
+	 * internal reasons. One use case is to reset the internal state of CEC
+	 * controllers for HDMI bridges.
+	 */
+	void (*hpd_notify)(struct drm_bridge *bridge,
+			   enum drm_connector_status status);
+
+	/**
+	 * @hpd_enable:
+	 *
+	 * Enable hot plug detection. From now on the bridge shall call
+	 * drm_bridge_hpd_notify() each time a change is detected in the output
+	 * connection status, until hot plug detection gets disabled with
+	 * @hpd_disable.
+	 *
+	 * This callback is optional and shall only be implemented by bridges
+	 * that support hot-plug notification without polling. Bridges that
+	 * implement it shall also implement the @hpd_disable callback and set
+	 * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops.
+	 */
+	void (*hpd_enable)(struct drm_bridge *bridge);
+
+	/**
+	 * @hpd_disable:
+	 *
+	 * Disable hot plug detection. Once this function returns the bridge
+	 * shall not call drm_bridge_hpd_notify() when a change in the output
+	 * connection status occurs.
+	 *
+	 * This callback is optional and shall only be implemented by bridges
+	 * that support hot-plug notification without polling. Bridges that
+	 * implement it shall also implement the @hpd_enable callback and set
+	 * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops.
+	 */
+	void (*hpd_disable)(struct drm_bridge *bridge);
 };
 
 /**
@@ -535,6 +652,39 @@  struct drm_bridge_timings {
 	bool dual_link;
 };
 
+/**
+ * enum drm_bridge_ops - Bitmask of operations supported by the bridge
+ */
+enum drm_bridge_ops {
+	/**
+	 * @DRM_BRIDGE_OP_DETECT: The bridge can detect displays connected to
+	 * its output. Bridges that set this flag shall implement the
+	 * &drm_bridge_funcs->detect callback.
+	 */
+	DRM_BRIDGE_OP_DETECT = BIT(0),
+	/**
+	 * @DRM_BRIDGE_OP_EDID: The bridge can retrieve the EDID of the display
+	 * connected to its output. Bridges that set this flag shall implement
+	 * the &drm_bridge_funcs->get_edid callback.
+	 */
+	DRM_BRIDGE_OP_EDID = BIT(1),
+	/**
+	 * @DRM_BRIDGE_OP_HPD: The bridge can detect hot-plug and hot-unplug
+	 * without requiring polling. Bridges that set this flag shall
+	 * implement the &drm_bridge_funcs->hpd_enable and
+	 * &drm_bridge_funcs->hpd_disable callbacks if they support enabling
+	 * and disabling hot-plug detection dynamically.
+	 */
+	DRM_BRIDGE_OP_HPD = BIT(2),
+	/**
+	 * @DRM_BRIDGE_OP_MODES: The bridge can retrieve the modes supported
+	 * by the display at its output. This does not include reading EDID
+	 * which is separately covered by @DRM_BRIDGE_OP_EDID. Bridges that set
+	 * this flag shall implement the &drm_bridge_funcs->get_modes callback.
+	 */
+	DRM_BRIDGE_OP_MODES = BIT(3),
+};
+
 /**
  * struct drm_bridge - central DRM bridge control structure
  */
@@ -563,6 +713,33 @@  struct drm_bridge {
 	const struct drm_bridge_funcs *funcs;
 	/** @driver_private: pointer to the bridge driver's internal context */
 	void *driver_private;
+	/** @ops: bitmask of operations supported by the bridge */
+	enum drm_bridge_ops ops;
+	/**
+	 * @type: Type of the connection at the bridge output
+	 * (DRM_MODE_CONNECTOR_*). For bridges at the end of this chain this
+	 * identifies the type of connected display.
+	 */
+	int type;
+	/**
+	 * @ddc: Associated I2C adapter for DDC access, if any.
+	 */
+	struct i2c_adapter *ddc;
+	/** private: */
+	/**
+	 * @hpd_mutex: Protects the @hpd_cb and @hpd_data fields.
+	 */
+	struct mutex hpd_mutex;
+	/**
+	 * @hpd_cb: Hot plug detection callback, registered with
+	 * drm_bridge_hpd_enable().
+	 */
+	void (*hpd_cb)(void *data, enum drm_connector_status status);
+	/**
+	 * @hpd_data: Private data passed to the Hot plug detection callback
+	 * @hpd_cb.
+	 */
+	void *hpd_data;
 };
 
 static inline struct drm_bridge *
@@ -669,6 +846,19 @@  drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
 					u32 output_fmt,
 					unsigned int *num_input_fmts);
 
+enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge);
+int drm_bridge_get_modes(struct drm_bridge *bridge,
+			 struct drm_connector *connector);
+struct edid *drm_bridge_get_edid(struct drm_bridge *bridge,
+				 struct drm_connector *connector);
+void drm_bridge_hpd_enable(struct drm_bridge *bridge,
+			   void (*cb)(void *data,
+				      enum drm_connector_status status),
+			   void *data);
+void drm_bridge_hpd_disable(struct drm_bridge *bridge);
+void drm_bridge_hpd_notify(struct drm_bridge *bridge,
+			   enum drm_connector_status status);
+
 #ifdef CONFIG_DRM_PANEL_BRIDGE
 struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel);
 struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel,