47  * A bridge is always attached to a single &drm_encoder at a time, but can be
50  *     [ CRTC ---> ] Encoder ---> Bridge A ---> Bridge B
52  * Here, the output of the encoder feeds to bridge A, and that furthers feeds to
53  * bridge B. Bridge chains can be arbitrarily long, and shall be fully linear:
54  * Chaining multiple bridges to the output of a bridge, or the same bridge to
66  * Display drivers are responsible for linking encoders with the first bridge
67  * in the chains. This is done by acquiring the appropriate bridge with
68  * devm_drm_of_get_bridge(). Once acquired, the bridge shall be attached to the
71  * Bridges are responsible for linking themselves with the next bridge in the
93  * DRM bridge chain functions shall be called manually.
96  * the bridge chain. Display drivers may use the drm_bridge_connector_init()
98  * connector-related operations exposed by the bridge (see the overview
99  * documentation of bridge operations for more details).
106  * the probing of the upstream driver and the bridge driver can be
111  *   MIPI-DSI host. In this case, the bridge driver will probe at some
113  *   EPROBE_DEFER as long as the bridge driver hasn't probed.
116  *   MIPI-DSI host. The bridge device uses the MIPI-DCS commands to be
117  *   controlled. In this case, the bridge device is a child of the
120  *   assured that the bridge driver is connected between the
127  *   host. The bridge device uses the MIPI-DCS commands to be
132  *   host. The bridge device uses a separate bus (such as I2C) to be
134  *   of the bridge and upstream drivers, so care must be taken to avoid
145  * - In its probe hook, the bridge driver must try to find its MIPI-DSI
147  *   to its host. The bridge driver is now functional.
151  *   the bridge driver is attached and registered, we can now look for
155  * the bridge driver are functional and we can't have a deadlock-like
160  * DOC: dsi bridge operations
173  * Ordinarily the downstream bridge DSI peripheral pre_enable will have been
186  * bridge &post_disable will be called before the DSI host's post_disable.
202  * drm_bridge_add - add the given bridge to the global bridge list
204  * @bridge: bridge control structure
206 void drm_bridge_add(struct drm_bridge *bridge)  in drm_bridge_add()  argument
208 	mutex_init(&bridge->hpd_mutex);  in drm_bridge_add()
211 	list_add_tail(&bridge->list, &bridge_list);  in drm_bridge_add()
216 static void drm_bridge_remove_void(void *bridge)  in drm_bridge_remove_void()  argument
218 	drm_bridge_remove(bridge);  in drm_bridge_remove_void()
224  * @dev: device to tie the bridge lifetime to
225  * @bridge: bridge control structure
232 int devm_drm_bridge_add(struct device *dev, struct drm_bridge *bridge)  in devm_drm_bridge_add()  argument
234 	drm_bridge_add(bridge);  in devm_drm_bridge_add()
235 	return devm_add_action_or_reset(dev, drm_bridge_remove_void, bridge);  in devm_drm_bridge_add()
240  * drm_bridge_remove - remove the given bridge from the global bridge list
242  * @bridge: bridge control structure
244 void drm_bridge_remove(struct drm_bridge *bridge)  in drm_bridge_remove()  argument
247 	list_del_init(&bridge->list);  in drm_bridge_remove()
250 	mutex_destroy(&bridge->hpd_mutex);  in drm_bridge_remove()
257 	struct drm_bridge *bridge = drm_priv_to_bridge(obj);  in drm_bridge_atomic_duplicate_priv_state()  local
260 	state = bridge->funcs->atomic_duplicate_state(bridge);  in drm_bridge_atomic_duplicate_priv_state()
269 	struct drm_bridge *bridge = drm_priv_to_bridge(obj);  in drm_bridge_atomic_destroy_priv_state()  local
271 	bridge->funcs->atomic_destroy_state(bridge, state);  in drm_bridge_atomic_destroy_priv_state()
280  * drm_bridge_attach - attach the bridge to an encoder's chain
283  * @bridge: bridge to attach
284  * @previous: previous bridge in the chain (optional)
287  * Called by a kms driver to link the bridge to an encoder's chain. The previous
288  * argument specifies the previous bridge in the chain. If NULL, the bridge is
290  * previous bridge's output.
292  * If non-NULL the previous bridge must be already attached by a call to this
302 int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge,  in drm_bridge_attach()  argument
308 	if (!encoder || !bridge)  in drm_bridge_attach()
314 	if (bridge->dev)  in drm_bridge_attach()
317 	bridge->dev = encoder->dev;  in drm_bridge_attach()
318 	bridge->encoder = encoder;  in drm_bridge_attach()
321 		list_add(&bridge->chain_node, &previous->chain_node);  in drm_bridge_attach()
323 		list_add(&bridge->chain_node, &encoder->bridge_chain);  in drm_bridge_attach()
325 	if (bridge->funcs->attach) {  in drm_bridge_attach()
326 		ret = bridge->funcs->attach(bridge, flags);  in drm_bridge_attach()
331 	if (bridge->funcs->atomic_reset) {  in drm_bridge_attach()
334 		state = bridge->funcs->atomic_reset(bridge);  in drm_bridge_attach()
340 		drm_atomic_private_obj_init(bridge->dev, &bridge->base,  in drm_bridge_attach()
348 	if (bridge->funcs->detach)  in drm_bridge_attach()
349 		bridge->funcs->detach(bridge);  in drm_bridge_attach()
352 	bridge->dev = NULL;  in drm_bridge_attach()
353 	bridge->encoder = NULL;  in drm_bridge_attach()
354 	list_del(&bridge->chain_node);  in drm_bridge_attach()
357 	DRM_ERROR("failed to attach bridge %pOF to encoder %s: %d\n",  in drm_bridge_attach()
358 		  bridge->of_node, encoder->name, ret);  in drm_bridge_attach()
360 	DRM_ERROR("failed to attach bridge to encoder %s: %d\n",  in drm_bridge_attach()
368 void drm_bridge_detach(struct drm_bridge *bridge)  in drm_bridge_detach()  argument
370 	if (WARN_ON(!bridge))  in drm_bridge_detach()
373 	if (WARN_ON(!bridge->dev))  in drm_bridge_detach()
376 	if (bridge->funcs->atomic_reset)  in drm_bridge_detach()
377 		drm_atomic_private_obj_fini(&bridge->base);  in drm_bridge_detach()
379 	if (bridge->funcs->detach)  in drm_bridge_detach()
380 		bridge->funcs->detach(bridge);  in drm_bridge_detach()
382 	list_del(&bridge->chain_node);  in drm_bridge_detach()
383 	bridge->dev = NULL;  in drm_bridge_detach()
387  * DOC: bridge operations
389  * Bridge drivers expose operations through the &drm_bridge_funcs structure.
391  * drm_bridge.c to call bridge operations. Those operations are divided in
392  * three big categories to support different parts of the bridge usage.
398  *   disable the bridge automatically.
405  *   Bridge drivers may implement the legacy version of those operations, or
414  *   &drm_bridge_funcs.atomic_get_input_bus_fmts allow bridge drivers to
418  *   atomic versions of those operations exist, bridge drivers that need to
426  *   puts additional burden on bridge drivers, especially for bridges that may
429  *   bridge, which doesn't always match the hardware architecture.
431  *   To simplify bridge drivers and make the connector implementation more
440  *   the bridge connector operations.
442  *   Bridge drivers shall implement the connector-related operations for all
443  *   the features that the bridge hardware support. For instance, if a bridge
446  *   bridge on a particular platform, as they could also be connected to an I2C
448  *   running platform is reported through the &drm_bridge.ops flags. Bridge
455  *   decide which bridge to delegate a connector operation to. This mechanism
457  *   bridge drivers, improving security by storing function pointers in
460  *   In order to ease transition, bridge drivers may support both the old and
462  *   connected-related bridge operations. Connector creation is then controlled
465  *   %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag, and bridge drivers shall then skip
467  *   be passed to the drm_bridge_attach() call for the downstream bridge.
468  *   Bridge drivers that implement the new model only shall return an error
471  *   should use the new model, and convert the bridge drivers they use if
478  * @bridge: bridge control structure
479  * @mode: desired mode to be set for the bridge
480  * @adjusted_mode: updated mode that works for this bridge
483  * encoder chain, starting from the first bridge to the last.
485  * Note: the bridge passed should be the one closest to the encoder
490 bool drm_bridge_chain_mode_fixup(struct drm_bridge *bridge,  in drm_bridge_chain_mode_fixup()  argument
496 	if (!bridge)  in drm_bridge_chain_mode_fixup()
499 	encoder = bridge->encoder;  in drm_bridge_chain_mode_fixup()
500 	list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {  in drm_bridge_chain_mode_fixup()
501 		if (!bridge->funcs->mode_fixup)  in drm_bridge_chain_mode_fixup()
504 		if (!bridge->funcs->mode_fixup(bridge, mode, adjusted_mode))  in drm_bridge_chain_mode_fixup()
515  * @bridge: bridge control structure
520  * chain, starting from the first bridge to the last. If at least one bridge
523  * Note: the bridge passed should be the one closest to the encoder.
529 drm_bridge_chain_mode_valid(struct drm_bridge *bridge,  in drm_bridge_chain_mode_valid()  argument
535 	if (!bridge)  in drm_bridge_chain_mode_valid()
538 	encoder = bridge->encoder;  in drm_bridge_chain_mode_valid()
539 	list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {  in drm_bridge_chain_mode_valid()
542 		if (!bridge->funcs->mode_valid)  in drm_bridge_chain_mode_valid()
545 		ret = bridge->funcs->mode_valid(bridge, info, mode);  in drm_bridge_chain_mode_valid()
557  * @bridge: bridge control structure
562  * encoder chain, starting from the first bridge to the last.
564  * Note: the bridge passed should be the one closest to the encoder
566 void drm_bridge_chain_mode_set(struct drm_bridge *bridge,  in drm_bridge_chain_mode_set()  argument
572 	if (!bridge)  in drm_bridge_chain_mode_set()
575 	encoder = bridge->encoder;  in drm_bridge_chain_mode_set()
576 	list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {  in drm_bridge_chain_mode_set()
577 		if (bridge->funcs->mode_set)  in drm_bridge_chain_mode_set()
578 			bridge->funcs->mode_set(bridge, mode, adjusted_mode);  in drm_bridge_chain_mode_set()
585  * @bridge: bridge control structure
590  * starting from the last bridge to the first. These are called before calling
593  * Note: the bridge passed should be the one closest to the encoder
595 void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,  in drm_atomic_bridge_chain_disable()  argument
601 	if (!bridge)  in drm_atomic_bridge_chain_disable()
604 	encoder = bridge->encoder;  in drm_atomic_bridge_chain_disable()
620 		if (iter == bridge)  in drm_atomic_bridge_chain_disable()
626 static void drm_atomic_bridge_call_post_disable(struct drm_bridge *bridge,  in drm_atomic_bridge_call_post_disable()  argument
629 	if (old_state && bridge->funcs->atomic_post_disable) {  in drm_atomic_bridge_call_post_disable()
634 							bridge);  in drm_atomic_bridge_call_post_disable()
638 		bridge->funcs->atomic_post_disable(bridge,  in drm_atomic_bridge_call_post_disable()
640 	} else if (bridge->funcs->post_disable) {  in drm_atomic_bridge_call_post_disable()
641 		bridge->funcs->post_disable(bridge);  in drm_atomic_bridge_call_post_disable()
648  * @bridge: bridge control structure
653  * starting from the first bridge to the last. These are called after completing
656  * If a bridge sets @pre_enable_prev_first, then the @post_disable for that
657  * bridge will be called before the previous one to reverse the @pre_enable
660  * Note: the bridge passed should be the one closest to the encoder
662 void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,  in drm_atomic_bridge_chain_post_disable()  argument
668 	if (!bridge)  in drm_atomic_bridge_chain_post_disable()
671 	encoder = bridge->encoder;  in drm_atomic_bridge_chain_post_disable()
673 	list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {  in drm_atomic_bridge_chain_post_disable()
676 		if (!list_is_last(&bridge->chain_node, &encoder->bridge_chain)) {  in drm_atomic_bridge_chain_post_disable()
677 			next = list_next_entry(bridge, chain_node);  in drm_atomic_bridge_chain_post_disable()
680 				/* next bridge had requested that prev  in drm_atomic_bridge_chain_post_disable()
685 				/* Find the next bridge that has NOT requested  in drm_atomic_bridge_chain_post_disable()
706 					if (next == bridge)  in drm_atomic_bridge_chain_post_disable()
715 		drm_atomic_bridge_call_post_disable(bridge, old_state);  in drm_atomic_bridge_chain_post_disable()
719 			bridge = limit;  in drm_atomic_bridge_chain_post_disable()
724 static void drm_atomic_bridge_call_pre_enable(struct drm_bridge *bridge,  in drm_atomic_bridge_call_pre_enable()  argument
727 	if (old_state && bridge->funcs->atomic_pre_enable) {  in drm_atomic_bridge_call_pre_enable()
732 							bridge);  in drm_atomic_bridge_call_pre_enable()
736 		bridge->funcs->atomic_pre_enable(bridge, old_bridge_state);  in drm_atomic_bridge_call_pre_enable()
737 	} else if (bridge->funcs->pre_enable) {  in drm_atomic_bridge_call_pre_enable()
738 		bridge->funcs->pre_enable(bridge);  in drm_atomic_bridge_call_pre_enable()
745  * @bridge: bridge control structure
750  * starting from the last bridge to the first. These are called before calling
753  * If a bridge sets @pre_enable_prev_first, then the pre_enable for the
754  * prev bridge will be called before pre_enable of this bridge.
756  * Note: the bridge passed should be the one closest to the encoder
758 void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,  in drm_atomic_bridge_chain_pre_enable()  argument
764 	if (!bridge)  in drm_atomic_bridge_chain_pre_enable()
767 	encoder = bridge->encoder;  in drm_atomic_bridge_chain_pre_enable()
772 			limit = bridge;  in drm_atomic_bridge_chain_pre_enable()
776 				if (next == bridge)  in drm_atomic_bridge_chain_pre_enable()
780 					/* Found first bridge that does NOT  in drm_atomic_bridge_chain_pre_enable()
789 				/* Call requested prev bridge pre_enable  in drm_atomic_bridge_chain_pre_enable()
793 					/* At the first bridge to request prev  in drm_atomic_bridge_chain_pre_enable()
808 		if (iter == bridge)  in drm_atomic_bridge_chain_pre_enable()
816  * @bridge: bridge control structure
821  * starting from the first bridge to the last. These are called after completing
824  * Note: the bridge passed should be the one closest to the encoder
826 void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge,  in drm_atomic_bridge_chain_enable()  argument
831 	if (!bridge)  in drm_atomic_bridge_chain_enable()
834 	encoder = bridge->encoder;  in drm_atomic_bridge_chain_enable()
835 	list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {  in drm_atomic_bridge_chain_enable()
836 		if (bridge->funcs->atomic_enable) {  in drm_atomic_bridge_chain_enable()
841 								bridge);  in drm_atomic_bridge_chain_enable()
845 			bridge->funcs->atomic_enable(bridge, old_bridge_state);  in drm_atomic_bridge_chain_enable()
846 		} else if (bridge->funcs->enable) {  in drm_atomic_bridge_chain_enable()
847 			bridge->funcs->enable(bridge);  in drm_atomic_bridge_chain_enable()
853 static int drm_atomic_bridge_check(struct drm_bridge *bridge,  in drm_atomic_bridge_check()  argument
857 	if (bridge->funcs->atomic_check) {  in drm_atomic_bridge_check()
862 							       bridge);  in drm_atomic_bridge_check()
866 		ret = bridge->funcs->atomic_check(bridge, bridge_state,  in drm_atomic_bridge_check()
870 	} else if (bridge->funcs->mode_fixup) {  in drm_atomic_bridge_check()
871 		if (!bridge->funcs->mode_fixup(bridge, &crtc_state->mode,  in drm_atomic_bridge_check()
896 	 * If bus format negotiation is not supported by this bridge, let's  in select_bus_fmt_recursive()
897 	 * pass MEDIA_BUS_FMT_FIXED to the previous bridge in the chain and  in select_bus_fmt_recursive()
913 		 * fine, as long as it does not access the bridge state.  in select_bus_fmt_recursive()
968  * It performs bus format negotiation between bridge elements. The negotiation
970  * @bridge.
973  * bridge element and testing them one by one. The test is recursive, meaning
976  * transcoded to the requested output format. When a bridge element does not
978  * the next bridge element will have to try a different format. If none of the
993  * bridge element that lacks this hook and asks the previous element in the
994  * chain to try MEDIA_BUS_FMT_FIXED. It's up to bridge drivers to decide what
1000 drm_atomic_bridge_chain_select_bus_fmts(struct drm_bridge *bridge,  in drm_atomic_bridge_chain_select_bus_fmts()  argument
1005 	struct drm_encoder *encoder = bridge->encoder;  in drm_atomic_bridge_chain_select_bus_fmts()
1050 		ret = select_bus_fmt_recursive(bridge, last_bridge, crtc_state,  in drm_atomic_bridge_chain_select_bus_fmts()
1062 drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge,  in drm_atomic_bridge_propagate_bus_flags()  argument
1070 	bridge_state = drm_atomic_get_new_bridge_state(state, bridge);  in drm_atomic_bridge_propagate_bus_flags()
1072 	/* No bridge state attached to this bridge => nothing to propagate. */  in drm_atomic_bridge_propagate_bus_flags()
1076 	next_bridge = drm_bridge_get_next_bridge(bridge);  in drm_atomic_bridge_propagate_bus_flags()
1080 	 * display_info flags for the last bridge, and propagate the input  in drm_atomic_bridge_propagate_bus_flags()
1081 	 * flags of the next bridge element to the output end of the current  in drm_atomic_bridge_propagate_bus_flags()
1082 	 * bridge when the bridge is not the last one.  in drm_atomic_bridge_propagate_bus_flags()
1094 		 * No bridge state attached to the next bridge, just leave the  in drm_atomic_bridge_propagate_bus_flags()
1104 	 * Propagate the output flags to the input end of the bridge. Again, it's  in drm_atomic_bridge_propagate_bus_flags()
1113  * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain
1114  * @bridge: bridge control structure
1121  * starting from the last bridge to the first. These are called before calling
1127 int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,  in drm_atomic_bridge_chain_check()  argument
1136 	if (!bridge)  in drm_atomic_bridge_chain_check()
1139 	ret = drm_atomic_bridge_chain_select_bus_fmts(bridge, crtc_state,  in drm_atomic_bridge_chain_check()
1144 	encoder = bridge->encoder;  in drm_atomic_bridge_chain_check()
1149 		 * Bus flags are propagated by default. If a bridge needs to  in drm_atomic_bridge_chain_check()
1162 		if (iter == bridge)  in drm_atomic_bridge_chain_check()
1171  * drm_bridge_detect - check if anything is attached to the bridge output
1172  * @bridge: bridge control structure
1174  * If the bridge supports output detection, as reported by the
1175  * DRM_BRIDGE_OP_DETECT bridge ops flag, call &drm_bridge_funcs.detect for the
1176  * bridge and return the connection status. Otherwise return
1180  * The detection status on success, or connector_status_unknown if the bridge
1183 enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge)  in drm_bridge_detect()  argument
1185 	if (!(bridge->ops & DRM_BRIDGE_OP_DETECT))  in drm_bridge_detect()
1188 	return bridge->funcs->detect(bridge);  in drm_bridge_detect()
1195  * @bridge: bridge control structure
1198  * If the bridge supports output modes retrieval, as reported by the
1199  * DRM_BRIDGE_OP_MODES bridge ops flag, call &drm_bridge_funcs.get_modes to
1206 int drm_bridge_get_modes(struct drm_bridge *bridge,  in drm_bridge_get_modes()  argument
1209 	if (!(bridge->ops & DRM_BRIDGE_OP_MODES))  in drm_bridge_get_modes()
1212 	return bridge->funcs->get_modes(bridge, connector);  in drm_bridge_get_modes()
1218  * @bridge: bridge control structure
1221  * If the bridge supports output EDID retrieval, as reported by the
1222  * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.edid_read to get
1231 const struct drm_edid *drm_bridge_edid_read(struct drm_bridge *bridge,  in drm_bridge_edid_read()  argument
1234 	if (!(bridge->ops & DRM_BRIDGE_OP_EDID))  in drm_bridge_edid_read()
1238 	if (!bridge->funcs->edid_read) {  in drm_bridge_edid_read()
1242 		edid = drm_bridge_get_edid(bridge, connector);  in drm_bridge_edid_read()
1253 	return bridge->funcs->edid_read(bridge, connector);  in drm_bridge_edid_read()
1259  * @bridge: bridge control structure
1262  * If the bridge supports output EDID retrieval, as reported by the
1263  * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.get_edid to
1271 struct edid *drm_bridge_get_edid(struct drm_bridge *bridge,  in drm_bridge_get_edid()  argument
1274 	if (!(bridge->ops & DRM_BRIDGE_OP_EDID))  in drm_bridge_get_edid()
1277 	return bridge->funcs->get_edid(bridge, connector);  in drm_bridge_get_edid()
1282  * drm_bridge_hpd_enable - enable hot plug detection for the bridge
1283  * @bridge: bridge control structure
1289  * called with @data when an output status change is detected by the bridge,
1293  * bridge->ops. This function shall not be called when the flag is not set.
1297  * the bridge.
1299 void drm_bridge_hpd_enable(struct drm_bridge *bridge,  in drm_bridge_hpd_enable()  argument
1304 	if (!(bridge->ops & DRM_BRIDGE_OP_HPD))  in drm_bridge_hpd_enable()
1307 	mutex_lock(&bridge->hpd_mutex);  in drm_bridge_hpd_enable()
1309 	if (WARN(bridge->hpd_cb, "Hot plug detection already enabled\n"))  in drm_bridge_hpd_enable()
1312 	bridge->hpd_cb = cb;  in drm_bridge_hpd_enable()
1313 	bridge->hpd_data = data;  in drm_bridge_hpd_enable()
1315 	if (bridge->funcs->hpd_enable)  in drm_bridge_hpd_enable()
1316 		bridge->funcs->hpd_enable(bridge);  in drm_bridge_hpd_enable()
1319 	mutex_unlock(&bridge->hpd_mutex);  in drm_bridge_hpd_enable()
1324  * drm_bridge_hpd_disable - disable hot plug detection for the bridge
1325  * @bridge: bridge control structure
1329  * Once this function returns the callback will not be called by the bridge
1333  * bridge->ops. This function shall not be called when the flag is not set.
1335 void drm_bridge_hpd_disable(struct drm_bridge *bridge)  in drm_bridge_hpd_disable()  argument
1337 	if (!(bridge->ops & DRM_BRIDGE_OP_HPD))  in drm_bridge_hpd_disable()
1340 	mutex_lock(&bridge->hpd_mutex);  in drm_bridge_hpd_disable()
1341 	if (bridge->funcs->hpd_disable)  in drm_bridge_hpd_disable()
1342 		bridge->funcs->hpd_disable(bridge);  in drm_bridge_hpd_disable()
1344 	bridge->hpd_cb = NULL;  in drm_bridge_hpd_disable()
1345 	bridge->hpd_data = NULL;  in drm_bridge_hpd_disable()
1346 	mutex_unlock(&bridge->hpd_mutex);  in drm_bridge_hpd_disable()
1352  * @bridge: bridge control structure
1355  * Bridge drivers shall call this function to report hot plug events when they
1361 void drm_bridge_hpd_notify(struct drm_bridge *bridge,  in drm_bridge_hpd_notify()  argument
1364 	mutex_lock(&bridge->hpd_mutex);  in drm_bridge_hpd_notify()
1365 	if (bridge->hpd_cb)  in drm_bridge_hpd_notify()
1366 		bridge->hpd_cb(bridge->hpd_data, status);  in drm_bridge_hpd_notify()
1367 	mutex_unlock(&bridge->hpd_mutex);  in drm_bridge_hpd_notify()
1373  * of_drm_find_bridge - find the bridge corresponding to the device node in
1374  *			the global bridge list
1383 	struct drm_bridge *bridge;  in of_drm_find_bridge()  local
1387 	list_for_each_entry(bridge, &bridge_list, list) {  in of_drm_find_bridge()
1388 		if (bridge->of_node == np) {  in of_drm_find_bridge()
1390 			return bridge;  in of_drm_find_bridge()
1411 		struct drm_bridge *bridge;  in drm_bridge_chains_info()  local
1415 		drm_for_each_bridge_in_chain(encoder, bridge) {  in drm_bridge_chains_info()
1417 				   bridge_idx, bridge->type, bridge->ops);  in drm_bridge_chains_info()
1420 			if (bridge->of_node)  in drm_bridge_chains_info()
1421 				drm_printf(&p, ", OF: %pOFfc", bridge->of_node);  in drm_bridge_chains_info()
1445 MODULE_DESCRIPTION("DRM bridge infrastructure");