drm/bridge: Add connector-related bridge operations and data (11f6c4b1) · Commits · 戴 / test

drivers/gpu/drm/drm_bridge.c

+200 −1

Original line number	Diff line number	Diff line
		@@ -95,6 +95,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);
		@@ -111,6 +113,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);

		@@ -241,7 +245,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
		@@ -271,6 +275,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.
		*/

		/**
		@@ -970,6 +1011,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

include/drm/drm_bridge.h

+191 −1

Original line number	Diff line number	Diff line
		@@ -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,

Admin message