[2/5] drm: of: introduce drm_of_find_panel_or_bridge
diff mbox

Message ID 20170204033635.10250-3-robh@kernel.org
State New
Headers show

Commit Message

Rob Herring Feb. 4, 2017, 3:36 a.m. UTC
Many drivers have a common pattern of searching the OF graph for either an
attached panel or bridge and then finding the DRM struct for the panel
or bridge. Also, most drivers need to handle deferred probing when the
DRM device is not yet instantiated. Create a common function,
drm_of_find_panel_or_bridge, to find the connected node and the
associated DRM panel or bridge device.

Signed-off-by: Rob Herring <robh@kernel.org>
---
 drivers/gpu/drm/drm_of.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++
 include/drm/drm_of.h     | 13 +++++++++++++
 2 files changed, 63 insertions(+)

Comments

Liviu Dudau Feb. 6, 2017, 10:18 a.m. UTC | #1
On Fri, Feb 03, 2017 at 09:36:32PM -0600, Rob Herring wrote:
> Many drivers have a common pattern of searching the OF graph for either an
> attached panel or bridge and then finding the DRM struct for the panel
> or bridge. Also, most drivers need to handle deferred probing when the
> DRM device is not yet instantiated. Create a common function,
> drm_of_find_panel_or_bridge, to find the connected node and the
> associated DRM panel or bridge device.
> 
> Signed-off-by: Rob Herring <robh@kernel.org>
> ---
>  drivers/gpu/drm/drm_of.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++
>  include/drm/drm_of.h     | 13 +++++++++++++
>  2 files changed, 63 insertions(+)
> 
> diff --git a/drivers/gpu/drm/drm_of.c b/drivers/gpu/drm/drm_of.c
> index 47848ed8ca48..b29ce2f52113 100644
> --- a/drivers/gpu/drm/drm_of.c
> +++ b/drivers/gpu/drm/drm_of.c
> @@ -3,7 +3,9 @@
>  #include <linux/list.h>
>  #include <linux/of_graph.h>
>  #include <drm/drmP.h>
> +#include <drm/drm_bridge.h>
>  #include <drm/drm_crtc.h>
> +#include <drm/drm_panel.h>
>  #include <drm/drm_of.h>
>  
>  static void drm_release_of(struct device *dev, void *data)
> @@ -207,3 +209,51 @@ int drm_of_encoder_active_endpoint(struct device_node *node,
>  	return -EINVAL;
>  }
>  EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
> +
> +/*
> + * drm_of_find_panel_or_bridge - return connected panel or bridge device
> + * @np: device tree node containing encoder input ports
> + * @panel: pointer to hold returned drm_panel
> + * @bridge: pointer to hold returned drm_bridge
> + *
> + * Given a DT node's port and endpoint number, find the connected node and
> + * return either the associated struct drm_panel or drm_bridge device.
> + *
> + * Returns zero if successful, or one of the standard error codes if it fails.
> + */
> +int drm_of_find_panel_or_bridge(const struct device_node *np,
> +				int port, int endpoint,
> +				struct drm_panel **panel,
> +				struct drm_bridge **bridge)
> +{
> +	int ret = -ENODEV;

Given that you never return 'ret' with -ENODEV can I suggest that you initialise 'ret'
with -EPROBE_DEFER and then you can get rid of the two assignments further down?

Otherwise, looks good to me.

Best regards,
Liviu

> +	struct device_node *remote;
> +
> +	remote = of_graph_get_remote_node(np, port, endpoint);
> +	if (!remote)
> +		return -ENODEV;
> +
> +	if (bridge)
> +		*bridge = NULL;
> +
> +	if (panel) {
> +		*panel = of_drm_find_panel(remote);
> +		if (*panel) {
> +			ret = 0;
> +			goto out_put;
> +		}
> +		ret = -EPROBE_DEFER;
> +	}
> +
> +	if (bridge) {
> +		*bridge = of_drm_find_bridge(remote);
> +		if (*bridge)
> +			ret = 0;
> +		else
> +			ret = -EPROBE_DEFER;
> +	}
> +out_put:
> +	of_node_put(remote);
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);
> diff --git a/include/drm/drm_of.h b/include/drm/drm_of.h
> index 26a64805cc15..f86507f0599b 100644
> --- a/include/drm/drm_of.h
> +++ b/include/drm/drm_of.h
> @@ -8,6 +8,8 @@ struct component_match;
>  struct device;
>  struct drm_device;
>  struct drm_encoder;
> +struct drm_panel;
> +struct drm_bridge;
>  struct device_node;
>  
>  #ifdef CONFIG_OF
> @@ -23,6 +25,10 @@ extern int drm_of_component_probe(struct device *dev,
>  extern int drm_of_encoder_active_endpoint(struct device_node *node,
>  					  struct drm_encoder *encoder,
>  					  struct of_endpoint *endpoint);
> +extern int drm_of_find_panel_or_bridge(const struct device_node *np,
> +				       int port, int endpoint,
> +				       struct drm_panel **panel,
> +				       struct drm_bridge **bridge);
>  #else
>  static inline uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
>  						  struct device_node *port)
> @@ -52,6 +58,13 @@ static inline int drm_of_encoder_active_endpoint(struct device_node *node,
>  {
>  	return -EINVAL;
>  }
> +static inline int drm_of_find_panel_or_bridge(const struct device_node *np,
> +					      int port, int endpoint,
> +					      struct drm_panel **panel,
> +					      struct drm_bridge **bridge)
> +{
> +	return -EINVAL;
> +}
>  #endif
>  
>  static inline int drm_of_encoder_active_endpoint_id(struct device_node *node,
> -- 
> 2.10.1
>
Philipp Zabel Feb. 6, 2017, 10:42 a.m. UTC | #2
On Fri, 2017-02-03 at 21:36 -0600, Rob Herring wrote:
> Many drivers have a common pattern of searching the OF graph for either an
> attached panel or bridge and then finding the DRM struct for the panel
> or bridge. Also, most drivers need to handle deferred probing when the
> DRM device is not yet instantiated. Create a common function,
> drm_of_find_panel_or_bridge, to find the connected node and the
> associated DRM panel or bridge device.
> 
> Signed-off-by: Rob Herring <robh@kernel.org>
> ---
>  drivers/gpu/drm/drm_of.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++
>  include/drm/drm_of.h     | 13 +++++++++++++
>  2 files changed, 63 insertions(+)
> 
> diff --git a/drivers/gpu/drm/drm_of.c b/drivers/gpu/drm/drm_of.c
> index 47848ed8ca48..b29ce2f52113 100644
> --- a/drivers/gpu/drm/drm_of.c
> +++ b/drivers/gpu/drm/drm_of.c
> @@ -3,7 +3,9 @@
>  #include <linux/list.h>
>  #include <linux/of_graph.h>
>  #include <drm/drmP.h>
> +#include <drm/drm_bridge.h>
>  #include <drm/drm_crtc.h>
> +#include <drm/drm_panel.h>
>  #include <drm/drm_of.h>
>  
>  static void drm_release_of(struct device *dev, void *data)
> @@ -207,3 +209,51 @@ int drm_of_encoder_active_endpoint(struct device_node *node,
>  	return -EINVAL;
>  }
>  EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
> +
> +/*
> + * drm_of_find_panel_or_bridge - return connected panel or bridge device
> + * @np: device tree node containing encoder input ports
> + * @panel: pointer to hold returned drm_panel
> + * @bridge: pointer to hold returned drm_bridge
> + *
> + * Given a DT node's port and endpoint number, find the connected node and
> + * return either the associated struct drm_panel or drm_bridge device.

Add a commend that at least one of panel, bridge must be set?

> + * Returns zero if successful, or one of the standard error codes if it fails.
> + */
> +int drm_of_find_panel_or_bridge(const struct device_node *np,
> +				int port, int endpoint,
> +				struct drm_panel **panel,
> +				struct drm_bridge **bridge)
> +{
> +	int ret = -ENODEV;

This is only returned if !panel && !bridge. I'd consider this invalid
usage of this function, so maybe use -EINVAL?

> +	struct device_node *remote;
> +
> +	remote = of_graph_get_remote_node(np, port, endpoint);
> +	if (!remote)
> +		return -ENODEV;
> +
> +	if (bridge)
> +		*bridge = NULL;

I would move this ^ ...

> +	if (panel) {
> +		*panel = of_drm_find_panel(remote);
> +		if (*panel) {

... here.

> +			ret = 0;
> +			goto out_put;
> +		}
> +		ret = -EPROBE_DEFER;
> +	}
> +
> +	if (bridge) {
> +		*bridge = of_drm_find_bridge(remote);
> +		if (*bridge)
> +			ret = 0;
> +		else
> +			ret = -EPROBE_DEFER;
> +	}
> +out_put:
> +	of_node_put(remote);
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);
> diff --git a/include/drm/drm_of.h b/include/drm/drm_of.h
> index 26a64805cc15..f86507f0599b 100644
> --- a/include/drm/drm_of.h
> +++ b/include/drm/drm_of.h
> @@ -8,6 +8,8 @@ struct component_match;
>  struct device;
>  struct drm_device;
>  struct drm_encoder;
> +struct drm_panel;
> +struct drm_bridge;
>  struct device_node;
>  
>  #ifdef CONFIG_OF
> @@ -23,6 +25,10 @@ extern int drm_of_component_probe(struct device *dev,
>  extern int drm_of_encoder_active_endpoint(struct device_node *node,
>  					  struct drm_encoder *encoder,
>  					  struct of_endpoint *endpoint);
> +extern int drm_of_find_panel_or_bridge(const struct device_node *np,
> +				       int port, int endpoint,
> +				       struct drm_panel **panel,
> +				       struct drm_bridge **bridge);
>  #else
>  static inline uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
>  						  struct device_node *port)
> @@ -52,6 +58,13 @@ static inline int drm_of_encoder_active_endpoint(struct device_node *node,
>  {
>  	return -EINVAL;
>  }
> +static inline int drm_of_find_panel_or_bridge(const struct device_node *np,
> +					      int port, int endpoint,
> +					      struct drm_panel **panel,
> +					      struct drm_bridge **bridge)
> +{
> +	return -EINVAL;
> +}
>  #endif
>  
>  static inline int drm_of_encoder_active_endpoint_id(struct device_node *node,

regards
Philipp
Rob Herring Feb. 6, 2017, 4:20 p.m. UTC | #3
On Mon, Feb 6, 2017 at 4:18 AM, Liviu Dudau <liviu.dudau@arm.com> wrote:
> On Fri, Feb 03, 2017 at 09:36:32PM -0600, Rob Herring wrote:
>> Many drivers have a common pattern of searching the OF graph for either an
>> attached panel or bridge and then finding the DRM struct for the panel
>> or bridge. Also, most drivers need to handle deferred probing when the
>> DRM device is not yet instantiated. Create a common function,
>> drm_of_find_panel_or_bridge, to find the connected node and the
>> associated DRM panel or bridge device.
>>
>> Signed-off-by: Rob Herring <robh@kernel.org>
>> ---
>>  drivers/gpu/drm/drm_of.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++
>>  include/drm/drm_of.h     | 13 +++++++++++++
>>  2 files changed, 63 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/drm_of.c b/drivers/gpu/drm/drm_of.c
>> index 47848ed8ca48..b29ce2f52113 100644
>> --- a/drivers/gpu/drm/drm_of.c
>> +++ b/drivers/gpu/drm/drm_of.c
>> @@ -3,7 +3,9 @@
>>  #include <linux/list.h>
>>  #include <linux/of_graph.h>
>>  #include <drm/drmP.h>
>> +#include <drm/drm_bridge.h>
>>  #include <drm/drm_crtc.h>
>> +#include <drm/drm_panel.h>
>>  #include <drm/drm_of.h>
>>
>>  static void drm_release_of(struct device *dev, void *data)
>> @@ -207,3 +209,51 @@ int drm_of_encoder_active_endpoint(struct device_node *node,
>>       return -EINVAL;
>>  }
>>  EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
>> +
>> +/*
>> + * drm_of_find_panel_or_bridge - return connected panel or bridge device
>> + * @np: device tree node containing encoder input ports
>> + * @panel: pointer to hold returned drm_panel
>> + * @bridge: pointer to hold returned drm_bridge
>> + *
>> + * Given a DT node's port and endpoint number, find the connected node and
>> + * return either the associated struct drm_panel or drm_bridge device.
>> + *
>> + * Returns zero if successful, or one of the standard error codes if it fails.
>> + */
>> +int drm_of_find_panel_or_bridge(const struct device_node *np,
>> +                             int port, int endpoint,
>> +                             struct drm_panel **panel,
>> +                             struct drm_bridge **bridge)
>> +{
>> +     int ret = -ENODEV;
>
> Given that you never return 'ret' with -ENODEV can I suggest that you initialise 'ret'
> with -EPROBE_DEFER and then you can get rid of the two assignments further down?

But I can if both panel and bridge are NULL. I'm going with Philipp's
suggestion of -EINVAL here.

Rob
Rob Herring Feb. 6, 2017, 4:53 p.m. UTC | #4
On Mon, Feb 06, 2017 at 11:42:48AM +0100, Philipp Zabel wrote:
> On Fri, 2017-02-03 at 21:36 -0600, Rob Herring wrote:
> > Many drivers have a common pattern of searching the OF graph for either an
> > attached panel or bridge and then finding the DRM struct for the panel
> > or bridge. Also, most drivers need to handle deferred probing when the
> > DRM device is not yet instantiated. Create a common function,
> > drm_of_find_panel_or_bridge, to find the connected node and the
> > associated DRM panel or bridge device.

[...]

> > +int drm_of_find_panel_or_bridge(const struct device_node *np,
> > +				int port, int endpoint,
> > +				struct drm_panel **panel,
> > +				struct drm_bridge **bridge)
> > +{
> > +	int ret = -ENODEV;
> 
> This is only returned if !panel && !bridge. I'd consider this invalid
> usage of this function, so maybe use -EINVAL?

Yes.

> > +	struct device_node *remote;
> > +
> > +	remote = of_graph_get_remote_node(np, port, endpoint);
> > +	if (!remote)
> > +		return -ENODEV;
> > +
> > +	if (bridge)
> > +		*bridge = NULL;
> 
> I would move this ^ ...
> 
> > +	if (panel) {
> > +		*panel = of_drm_find_panel(remote);
> > +		if (*panel) {
> 
> ... here.

Okay.

> > +			ret = 0;
> > +			goto out_put;
> > +		}
> > +		ret = -EPROBE_DEFER;
> > +	}
> > +
> > +	if (bridge) {
> > +		*bridge = of_drm_find_bridge(remote);
> > +		if (*bridge)
> > +			ret = 0;
> > +		else
> > +			ret = -EPROBE_DEFER;
> > +	}
> > +out_put:
> > +	of_node_put(remote);
> > +	return ret;
> > +}

I've ended up re-writing things a bit getting rid of the goto and the 
result looks like this:

int drm_of_find_panel_or_bridge(const struct device_node *np,
				int port, int endpoint,
				struct drm_panel **panel,
				struct drm_bridge **bridge)
{
	int ret = -EPROBE_DEFER;
	struct device_node *remote;

	if (!panel && !bridge)
		return -EINVAL;

	remote = of_graph_get_remote_node(np, port, endpoint);
	if (!remote)
		return -ENODEV;

	if (panel) {
		*panel = of_drm_find_panel(remote);
		if (*panel) {
			if (bridge)
				*bridge = NULL;
			ret = 0;
		}
	}

	/* No panel found yet, check for a bridge next. */
	if (ret && bridge) {
		*bridge = of_drm_find_bridge(remote);
		if (*bridge)
			ret = 0;
	}

	of_node_put(remote);
	return ret;
}
Philipp Zabel Feb. 6, 2017, 5:45 p.m. UTC | #5
On Mon, 2017-02-06 at 10:53 -0600, Rob Herring wrote:
> On Mon, Feb 06, 2017 at 11:42:48AM +0100, Philipp Zabel wrote:
> > On Fri, 2017-02-03 at 21:36 -0600, Rob Herring wrote:
> > > Many drivers have a common pattern of searching the OF graph for either an
> > > attached panel or bridge and then finding the DRM struct for the panel
> > > or bridge. Also, most drivers need to handle deferred probing when the
> > > DRM device is not yet instantiated. Create a common function,
> > > drm_of_find_panel_or_bridge, to find the connected node and the
> > > associated DRM panel or bridge device.
> 
> [...]
> 
> > > +int drm_of_find_panel_or_bridge(const struct device_node *np,
> > > +				int port, int endpoint,
> > > +				struct drm_panel **panel,
> > > +				struct drm_bridge **bridge)
> > > +{
> > > +	int ret = -ENODEV;
> > 
> > This is only returned if !panel && !bridge. I'd consider this invalid
> > usage of this function, so maybe use -EINVAL?
> 
> Yes.
> 
> > > +	struct device_node *remote;
> > > +
> > > +	remote = of_graph_get_remote_node(np, port, endpoint);
> > > +	if (!remote)
> > > +		return -ENODEV;
> > > +
> > > +	if (bridge)
> > > +		*bridge = NULL;
> > 
> > I would move this ^ ...
> > 
> > > +	if (panel) {
> > > +		*panel = of_drm_find_panel(remote);
> > > +		if (*panel) {
> > 
> > ... here.
> 
> Okay.
> 
> > > +			ret = 0;
> > > +			goto out_put;
> > > +		}
> > > +		ret = -EPROBE_DEFER;
> > > +	}
> > > +
> > > +	if (bridge) {
> > > +		*bridge = of_drm_find_bridge(remote);
> > > +		if (*bridge)
> > > +			ret = 0;
> > > +		else
> > > +			ret = -EPROBE_DEFER;
> > > +	}
> > > +out_put:
> > > +	of_node_put(remote);
> > > +	return ret;
> > > +}
> 
> I've ended up re-writing things a bit getting rid of the goto and the 
> result looks like this:

Looks good to me.

> int drm_of_find_panel_or_bridge(const struct device_node *np,
> 				int port, int endpoint,
> 				struct drm_panel **panel,
> 				struct drm_bridge **bridge)
> {
> 	int ret = -EPROBE_DEFER;
> 	struct device_node *remote;
> 
> 	if (!panel && !bridge)
> 		return -EINVAL;
> 
> 	remote = of_graph_get_remote_node(np, port, endpoint);
> 	if (!remote)
> 		return -ENODEV;
> 
> 	if (panel) {
> 		*panel = of_drm_find_panel(remote);
> 		if (*panel) {
> 			if (bridge)
> 				*bridge = NULL;

With the goto out_put gone, I'm conflicted whether I find this clearer
here, or ...

> 			ret = 0;
> 		}
> 	}
> 
> 	/* No panel found yet, check for a bridge next. */
> 	if (ret && bridge) {
> 		*bridge = of_drm_find_bridge(remote);
> 		if (*bridge)
> 			ret = 0;
> 	}

... even down here:

	if (bridge) {
		if (ret) {
			/* No panel found yet, check for a bridge next. */
			*bridge = of_drm_find_bridge(remote)
			if (*bridge)
				ret = 0;
		} else {
			*bridge = NULL;
		}
	}

That way bridge doesn't have to be checked twice and all the
modification of *bridge is in the same block.

> 
> 	of_node_put(remote);
> 	return ret;
> }

Either way,

Acked-by: Philipp Zabel <p.zabel@pengutronix.de>

regards
Philipp
Frank Rowand Feb. 10, 2017, 7:42 p.m. UTC | #6
On 02/03/17 19:36, Rob Herring wrote:
> Many drivers have a common pattern of searching the OF graph for either an
> attached panel or bridge and then finding the DRM struct for the panel
> or bridge. Also, most drivers need to handle deferred probing when the
> DRM device is not yet instantiated. Create a common function,
> drm_of_find_panel_or_bridge, to find the connected node and the
> associated DRM panel or bridge device.
> 
> Signed-off-by: Rob Herring <robh@kernel.org>
> ---
>  drivers/gpu/drm/drm_of.c | 50 ++++++++++++++++++++++++++++++++++++++++++++++++
>  include/drm/drm_of.h     | 13 +++++++++++++
>  2 files changed, 63 insertions(+)
> 
> diff --git a/drivers/gpu/drm/drm_of.c b/drivers/gpu/drm/drm_of.c
> index 47848ed8ca48..b29ce2f52113 100644
> --- a/drivers/gpu/drm/drm_of.c
> +++ b/drivers/gpu/drm/drm_of.c
> @@ -3,7 +3,9 @@
>  #include <linux/list.h>
>  #include <linux/of_graph.h>
>  #include <drm/drmP.h>
> +#include <drm/drm_bridge.h>
>  #include <drm/drm_crtc.h>
> +#include <drm/drm_panel.h>
>  #include <drm/drm_of.h>
>  
>  static void drm_release_of(struct device *dev, void *data)
> @@ -207,3 +209,51 @@ int drm_of_encoder_active_endpoint(struct device_node *node,
>  	return -EINVAL;
>  }
>  EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
> +
> +/*
> + * drm_of_find_panel_or_bridge - return connected panel or bridge device
> + * @np: device tree node containing encoder input ports

      @port: ....
      @endpoint: ....


> + * @panel: pointer to hold returned drm_panel
> + * @bridge: pointer to hold returned drm_bridge
> + *
> + * Given a DT node's port and endpoint number, find the connected node and
> + * return either the associated struct drm_panel or drm_bridge device.
> + *
> + * Returns zero if successful, or one of the standard error codes if it fails.
> + */
> +int drm_of_find_panel_or_bridge(const struct device_node *np,
> +				int port, int endpoint,
> +				struct drm_panel **panel,
> +				struct drm_bridge **bridge)
> +{

< snip >

Patch
diff mbox

diff --git a/drivers/gpu/drm/drm_of.c b/drivers/gpu/drm/drm_of.c
index 47848ed8ca48..b29ce2f52113 100644
--- a/drivers/gpu/drm/drm_of.c
+++ b/drivers/gpu/drm/drm_of.c
@@ -3,7 +3,9 @@ 
 #include <linux/list.h>
 #include <linux/of_graph.h>
 #include <drm/drmP.h>
+#include <drm/drm_bridge.h>
 #include <drm/drm_crtc.h>
+#include <drm/drm_panel.h>
 #include <drm/drm_of.h>
 
 static void drm_release_of(struct device *dev, void *data)
@@ -207,3 +209,51 @@  int drm_of_encoder_active_endpoint(struct device_node *node,
 	return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
+
+/*
+ * drm_of_find_panel_or_bridge - return connected panel or bridge device
+ * @np: device tree node containing encoder input ports
+ * @panel: pointer to hold returned drm_panel
+ * @bridge: pointer to hold returned drm_bridge
+ *
+ * Given a DT node's port and endpoint number, find the connected node and
+ * return either the associated struct drm_panel or drm_bridge device.
+ *
+ * Returns zero if successful, or one of the standard error codes if it fails.
+ */
+int drm_of_find_panel_or_bridge(const struct device_node *np,
+				int port, int endpoint,
+				struct drm_panel **panel,
+				struct drm_bridge **bridge)
+{
+	int ret = -ENODEV;
+	struct device_node *remote;
+
+	remote = of_graph_get_remote_node(np, port, endpoint);
+	if (!remote)
+		return -ENODEV;
+
+	if (bridge)
+		*bridge = NULL;
+
+	if (panel) {
+		*panel = of_drm_find_panel(remote);
+		if (*panel) {
+			ret = 0;
+			goto out_put;
+		}
+		ret = -EPROBE_DEFER;
+	}
+
+	if (bridge) {
+		*bridge = of_drm_find_bridge(remote);
+		if (*bridge)
+			ret = 0;
+		else
+			ret = -EPROBE_DEFER;
+	}
+out_put:
+	of_node_put(remote);
+	return ret;
+}
+EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);
diff --git a/include/drm/drm_of.h b/include/drm/drm_of.h
index 26a64805cc15..f86507f0599b 100644
--- a/include/drm/drm_of.h
+++ b/include/drm/drm_of.h
@@ -8,6 +8,8 @@  struct component_match;
 struct device;
 struct drm_device;
 struct drm_encoder;
+struct drm_panel;
+struct drm_bridge;
 struct device_node;
 
 #ifdef CONFIG_OF
@@ -23,6 +25,10 @@  extern int drm_of_component_probe(struct device *dev,
 extern int drm_of_encoder_active_endpoint(struct device_node *node,
 					  struct drm_encoder *encoder,
 					  struct of_endpoint *endpoint);
+extern int drm_of_find_panel_or_bridge(const struct device_node *np,
+				       int port, int endpoint,
+				       struct drm_panel **panel,
+				       struct drm_bridge **bridge);
 #else
 static inline uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
 						  struct device_node *port)
@@ -52,6 +58,13 @@  static inline int drm_of_encoder_active_endpoint(struct device_node *node,
 {
 	return -EINVAL;
 }
+static inline int drm_of_find_panel_or_bridge(const struct device_node *np,
+					      int port, int endpoint,
+					      struct drm_panel **panel,
+					      struct drm_bridge **bridge)
+{
+	return -EINVAL;
+}
 #endif
 
 static inline int drm_of_encoder_active_endpoint_id(struct device_node *node,