/* * Copyright (c) 2016 Intel Corporation * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission.  The copyright holders make no representations * about the suitability of this software for any purpose.  It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef __DRM_BRIDGE_H__#define __DRM_BRIDGE_H__ #include <linux/cleanup.h>#include <linux/ctype.h>#include <linux/list.h>#include <linux/mutex.h> #include <drm/drm_atomic.h>#include <drm/drm_encoder.h>#include <drm/drm_mode_object.h>#include <drm/drm_modes.h> struct cec_msg;struct device_node; struct drm_bridge;struct drm_bridge_timings;struct drm_connector;struct drm_display_info;struct drm_edid;struct drm_minor;struct drm_panel;struct hdmi_codec_daifmt;struct hdmi_codec_params;struct i2c_adapter; /** * enum drm_bridge_attach_flags - Flags for &drm_bridge_funcs.attach */enum drm_bridge_attach_flags {	/**	 * @DRM_BRIDGE_ATTACH_NO_CONNECTOR: When this flag is set the bridge	 * shall not create a drm_connector.	 */	DRM_BRIDGE_ATTACH_NO_CONNECTOR = BIT(0),}; /** * struct drm_bridge_funcs - drm_bridge control functions */struct drm_bridge_funcs {	/**	 * @attach:	 *	 * This callback is invoked whenever our bridge is being attached to a	 * &drm_encoder. The flags argument tunes the behaviour of the attach	 * operation (see DRM_BRIDGE_ATTACH_*).	 *	 * The @attach callback is optional.	 *	 * RETURNS:	 *	 * Zero on success, error code on failure.	 */	int (*attach)(struct drm_bridge *bridge, struct drm_encoder *encoder,		      enum drm_bridge_attach_flags flags); 	/**	 * @destroy:	 *	 * This callback is invoked when the bridge is about to be	 * deallocated.	 *	 * The @destroy callback is optional.	 */	void (*destroy)(struct drm_bridge *bridge); 	/**	 * @detach:	 *	 * This callback is invoked whenever our bridge is being detached from a	 * &drm_encoder.	 *	 * The @detach callback is optional.	 */	void (*detach)(struct drm_bridge *bridge); 	/**	 * @mode_valid:	 *	 * This callback is used to check if a specific mode is valid in this	 * bridge. This should be implemented if the bridge has some sort of	 * restriction in the modes it can display. For example, a given bridge	 * may be responsible to set a clock value. If the clock can not	 * produce all the values for the available modes then this callback	 * can be used to restrict the number of modes to only the ones that	 * can be displayed.	 *	 * This hook is used by the probe helpers to filter the mode list in	 * drm_helper_probe_single_connector_modes(), and it is used by the	 * atomic helpers to validate modes supplied by userspace in	 * drm_atomic_helper_check_modeset().	 *	 * The @mode_valid callback is optional.	 *	 * NOTE:	 *	 * Since this function is both called from the check phase of an atomic	 * commit, and the mode validation in the probe paths it is not allowed	 * to look at anything else but the passed-in mode, and validate it	 * against configuration-invariant hardware constraints. Any further	 * limits which depend upon the configuration can only be checked in	 * @mode_fixup.	 *	 * RETURNS:	 *	 * drm_mode_status Enum	 */	enum drm_mode_status (*mode_valid)(struct drm_bridge *bridge,					   const struct drm_display_info *info,					   const struct drm_display_mode *mode); 	/**	 * @mode_fixup:	 *	 * This callback is used to validate and adjust a mode. The parameter	 * mode is the display mode that should be fed to the next element in	 * the display chain, either the final &drm_connector or the next	 * &drm_bridge. The parameter adjusted_mode is the input mode the bridge	 * requires. It can be modified by this callback and does not need to	 * match mode. See also &drm_crtc_state.adjusted_mode for more details.	 *	 * This is the only hook that allows a bridge to reject a modeset. If	 * this function passes all other callbacks must succeed for this	 * configuration.	 *	 * The mode_fixup callback is optional. &drm_bridge_funcs.mode_fixup()	 * is not called when &drm_bridge_funcs.atomic_check() is implemented,	 * so only one of them should be provided.	 *	 * NOTE:	 *	 * This function is called in the check phase of atomic modesets, which	 * can be aborted for any reason (including on userspace's request to	 * just check whether a configuration would be possible). Drivers MUST	 * NOT touch any persistent state (hardware or software) or data	 * structures except the passed in @state parameter.	 *	 * Also beware that userspace can request its own custom modes, neither	 * core nor helpers filter modes to the list of probe modes reported by	 * the GETCONNECTOR IOCTL and stored in &drm_connector.modes. To ensure	 * that modes are filtered consistently put any bridge constraints and	 * limits checks into @mode_valid.	 *	 * RETURNS:	 *	 * True if an acceptable configuration is possible, false if the modeset	 * operation should be rejected.	 */	bool (*mode_fixup)(struct drm_bridge *bridge,			   const struct drm_display_mode *mode,			   struct drm_display_mode *adjusted_mode); 	/**	 * @mode_set:	 *	 * This callback should set the given mode on the bridge. It is called	 * after the @mode_set callback for the preceding element in the display	 * pipeline has been called already. If the bridge is the first element	 * then this would be &drm_encoder_helper_funcs.mode_set. The display	 * pipe (i.e.  clocks and timing signals) is off when this function is	 * called.	 *	 * The adjusted_mode parameter is the mode output by the CRTC for the	 * first bridge in the chain. It can be different from the mode	 * parameter that contains the desired mode for the connector at the end	 * of the bridges chain, for instance when the first bridge in the chain	 * performs scaling. The adjusted mode is mostly useful for the first	 * bridge in the chain and is likely irrelevant for the other bridges.	 *	 * For atomic drivers the adjusted_mode is the mode stored in	 * &drm_crtc_state.adjusted_mode.	 *	 * NOTE:	 *	 * This is deprecated, do not use!	 * New drivers shall set their mode in the	 * &drm_bridge_funcs.atomic_enable operation.	 */	void (*mode_set)(struct drm_bridge *bridge,			 const struct drm_display_mode *mode,			 const struct drm_display_mode *adjusted_mode); 	/**	 * @atomic_pre_enable:	 *	 * This callback should enable the bridge. It is called right before	 * the preceding element in the display pipe is enabled. If the	 * preceding element is a bridge this means it's called before that	 * bridge's @atomic_pre_enable or @pre_enable function. If the preceding	 * element is a &drm_encoder it's called right before the encoder's	 * &drm_encoder_helper_funcs.atomic_enable hook.	 *	 * The display pipe (i.e. clocks and timing signals) feeding this bridge	 * will not yet be running when this callback is called. The bridge must	 * not enable the display link feeding the next bridge in the chain (if	 * there is one) when this callback is called.	 *	 * The @atomic_pre_enable callback is optional.	 */	void (*atomic_pre_enable)(struct drm_bridge *bridge,				  struct drm_atomic_commit *state); 	/**	 * @atomic_enable:	 *	 * This callback should enable the bridge. It is called right after	 * the preceding element in the display pipe is enabled. If the	 * preceding element is a bridge this means it's called after that	 * bridge's @atomic_enable or @enable function. If the preceding element	 * is a &drm_encoder it's called right after the encoder's	 * &drm_encoder_helper_funcs.atomic_enable hook.	 *	 * The bridge can assume that the display pipe (i.e. clocks and timing	 * signals) feeding it is running when this callback is called. This	 * callback must enable the display link feeding the next bridge in the	 * chain if there is one.	 *	 * The @atomic_enable callback is optional.	 */	void (*atomic_enable)(struct drm_bridge *bridge,			      struct drm_atomic_commit *state);	/**	 * @atomic_disable:	 *	 * This callback should disable the bridge. It is called right before	 * the preceding element in the display pipe is disabled. If the	 * preceding element is a bridge this means it's called before that	 * bridge's @atomic_disable or @disable vfunc. If the preceding element	 * is a &drm_encoder it's called right before the	 * &drm_encoder_helper_funcs.atomic_disable hook.	 *	 * The bridge can assume that the display pipe (i.e. clocks and timing	 * signals) feeding it is still running when this callback is called.	 *	 * The @atomic_disable callback is optional.	 */	void (*atomic_disable)(struct drm_bridge *bridge,			       struct drm_atomic_commit *state); 	/**	 * @atomic_post_disable:	 *	 * This callback should disable the bridge. It is called right after the	 * preceding element in the display pipe is disabled. If the preceding	 * element is a bridge this means it's called after that bridge's	 * @atomic_post_disable or @post_disable function. If the preceding	 * element is a &drm_encoder it's called right after the encoder's	 * &drm_encoder_helper_funcs.atomic_disable hook.	 *	 * The bridge must assume that the display pipe (i.e. clocks and timing	 * signals) feeding it is no longer running when this callback is	 * called.	 *	 * The @atomic_post_disable callback is optional.	 */	void (*atomic_post_disable)(struct drm_bridge *bridge,				    struct drm_atomic_commit *state); 	/**	 * @atomic_duplicate_state:	 *	 * Duplicate the current bridge state object (which is guaranteed to be	 * non-NULL).	 *	 * The atomic_duplicate_state hook is mandatory if the bridge	 * implements any of the atomic hooks, and should be left unassigned	 * otherwise. For bridges that don't subclass &drm_bridge_state, the	 * drm_atomic_helper_bridge_duplicate_state() helper function shall be	 * used to implement this hook.	 *	 * RETURNS:	 * A valid drm_bridge_state object or NULL if the allocation fails.	 */	struct drm_bridge_state *(*atomic_duplicate_state)(struct drm_bridge *bridge); 	/**	 * @atomic_destroy_state:	 *	 * Destroy a bridge state object previously allocated by	 * &drm_bridge_funcs.atomic_duplicate_state().	 *	 * The atomic_destroy_state hook is mandatory if the bridge implements	 * any of the atomic hooks, and should be left unassigned otherwise.	 * For bridges that don't subclass &drm_bridge_state, the	 * drm_atomic_helper_bridge_destroy_state() helper function shall be	 * used to implement this hook.	 */	void (*atomic_destroy_state)(struct drm_bridge *bridge,				     struct drm_bridge_state *state); 	/**	 * @atomic_get_output_bus_fmts:	 *	 * Return the supported bus formats on the output end of a bridge.	 * The returned array must be allocated with kmalloc() and will be	 * freed by the caller. If the allocation fails, NULL should be	 * returned. num_output_fmts must be set to the returned array size.	 * Formats listed in the returned array should be listed in decreasing	 * preference order (the core will try all formats until it finds one	 * that works).	 *	 * This method is only called on the last element of the bridge chain	 * as part of the bus format negotiation process that happens in	 * &drm_atomic_bridge_chain_select_bus_fmts().	 * This method is optional. When not implemented, the core will	 * fall back to &drm_connector.display_info.bus_formats[0] if	 * &drm_connector.display_info.num_bus_formats > 0,	 * or to MEDIA_BUS_FMT_FIXED otherwise.	 */	u32 *(*atomic_get_output_bus_fmts)(struct drm_bridge *bridge,					   struct drm_bridge_state *bridge_state,					   struct drm_crtc_state *crtc_state,					   struct drm_connector_state *conn_state,					   unsigned int *num_output_fmts); 	/**	 * @atomic_get_input_bus_fmts:	 *	 * Return the supported bus formats on the input end of a bridge for	 * a specific output bus format.	 *	 * The returned array must be allocated with kmalloc() and will be	 * freed by the caller. If the allocation fails, NULL should be	 * returned. num_input_fmts must be set to the returned array size.	 * Formats listed in the returned array should be listed in decreasing	 * preference order (the core will try all formats until it finds one	 * that works). When the format is not supported NULL should be	 * returned and num_input_fmts should be set to 0.	 *	 * This method is called on all elements of the bridge chain as part of	 * the bus format negotiation process that happens in	 * drm_atomic_bridge_chain_select_bus_fmts().	 * This method is optional. When not implemented, the core will bypass	 * bus format negotiation on this element of the bridge without	 * failing, and the previous element in the chain will be passed	 * MEDIA_BUS_FMT_FIXED as its output bus format.	 *	 * Bridge drivers that need to support being linked to bridges that are	 * not supporting bus format negotiation should handle the	 * output_fmt == MEDIA_BUS_FMT_FIXED case appropriately, by selecting a	 * sensible default value or extracting this information from somewhere	 * else (FW property, &drm_display_mode, &drm_display_info, ...)	 *	 * Note: Even if input format selection on the first bridge has no	 * impact on the negotiation process (bus format negotiation stops once	 * we reach the first element of the chain), drivers are expected to	 * return accurate input formats as the input format may be used to	 * configure the CRTC output appropriately.	 */	u32 *(*atomic_get_input_bus_fmts)(struct drm_bridge *bridge,					  struct drm_bridge_state *bridge_state,					  struct drm_crtc_state *crtc_state,					  struct drm_connector_state *conn_state,					  u32 output_fmt,					  unsigned int *num_input_fmts); 	/**	 * @atomic_check:	 *	 * This method is responsible for checking bridge state correctness.	 * It can also check the state of the surrounding components in chain	 * to make sure the whole pipeline can work properly.	 *	 * &drm_bridge_funcs.atomic_check() hooks are called in reverse	 * order (from the last to the first bridge).	 *	 * This method is optional. &drm_bridge_funcs.mode_fixup() is not	 * called when &drm_bridge_funcs.atomic_check() is implemented, so only	 * one of them should be provided.	 *	 * If drivers need to tweak &drm_bridge_state.input_bus_cfg.flags or	 * &drm_bridge_state.output_bus_cfg.flags it should happen in	 * this function. By default the &drm_bridge_state.output_bus_cfg.flags	 * field is set to the next bridge	 * &drm_bridge_state.input_bus_cfg.flags value or	 * &drm_connector.display_info.bus_flags if the bridge is the last	 * element in the chain.	 *	 * RETURNS:	 * zero if the check passed, a negative error code otherwise.	 */	int (*atomic_check)(struct drm_bridge *bridge,			    struct drm_bridge_state *bridge_state,			    struct drm_crtc_state *crtc_state,			    struct drm_connector_state *conn_state); 	/**	 * @atomic_create_state:	 *	 * Allocate a pristine, initialized, state for the bridge	 * object and return it. This callback must have no side	 * effects: in particular, the returned state must not be	 * assigned to the object's state pointer and it must not affect	 * the hardware state.	 *	 * RETURNS:	 *	 * A new, pristine, bridge state instance or an error pointer	 * on failure.	 */	struct drm_bridge_state *(*atomic_create_state)(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,					    struct drm_connector *connector); 	/**	 * @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->edid_read 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); 	/**	 * @edid_read:	 *	 * Read the EDID data of the connected display.	 *	 * The @edid_read 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 shall not be stored internally by bridge drivers for	 * future usage.	 *	 * RETURNS:	 *	 * An edid structure newly allocated with drm_edid_alloc() or returned	 * from drm_edid_read() family of functions on success, or NULL	 * otherwise. The caller is responsible for freeing the returned edid	 * structure with drm_edid_free().	 */	const struct drm_edid *(*edid_read)(struct drm_bridge *bridge,					    struct drm_connector *connector); 	/**

Lines 1–500 of 1533. Load more