1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef __DRM_OF_H__
  3#define __DRM_OF_H__
  4
  5#include <linux/of_graph.h>
  6#if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_DRM_PANEL_BRIDGE)
  7#include <drm/drm_bridge.h>
  8#endif
  9
 10struct component_master_ops;
 11struct component_match;
 12struct device;
 13struct drm_device;
 14struct drm_encoder;
 15struct drm_panel;
 16struct drm_bridge;
 17struct device_node;
 18
 19#ifdef CONFIG_OF
 20uint32_t drm_of_crtc_port_mask(struct drm_device *dev,
 21			    struct device_node *port);
 22uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
 23				    struct device_node *port);
 24void drm_of_component_match_add(struct device *master,
 25				struct component_match **matchptr,
 26				int (*compare)(struct device *, void *),
 27				struct device_node *node);
 28int drm_of_component_probe(struct device *dev,
 29			   int (*compare_of)(struct device *, void *),
 30			   const struct component_master_ops *m_ops);
 31int drm_of_encoder_active_endpoint(struct device_node *node,
 32				   struct drm_encoder *encoder,
 33				   struct of_endpoint *endpoint);
 34int drm_of_find_panel_or_bridge(const struct device_node *np,
 35				int port, int endpoint,
 36				struct drm_panel **panel,
 37				struct drm_bridge **bridge);
 38#else
 39static inline uint32_t drm_of_crtc_port_mask(struct drm_device *dev,
 40					  struct device_node *port)
 41{
 42	return 0;
 43}
 44
 45static inline uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
 46						  struct device_node *port)
 47{
 48	return 0;
 49}
 50
 51static inline void
 52drm_of_component_match_add(struct device *master,
 53			   struct component_match **matchptr,
 54			   int (*compare)(struct device *, void *),
 55			   struct device_node *node)
 56{
 57}
 58
 59static inline int
 60drm_of_component_probe(struct device *dev,
 61		       int (*compare_of)(struct device *, void *),
 62		       const struct component_master_ops *m_ops)
 63{
 64	return -EINVAL;
 65}
 66
 67static inline int drm_of_encoder_active_endpoint(struct device_node *node,
 68						 struct drm_encoder *encoder,
 69						 struct of_endpoint *endpoint)
 70{
 71	return -EINVAL;
 72}
 73static inline int drm_of_find_panel_or_bridge(const struct device_node *np,
 74					      int port, int endpoint,
 75					      struct drm_panel **panel,
 76					      struct drm_bridge **bridge)
 77{
 78	return -EINVAL;
 79}
 80#endif
 81
 82/*
 83 * drm_of_panel_bridge_remove - remove panel bridge
 84 * @np: device tree node containing panel bridge output ports
 85 *
 86 * Remove the panel bridge of a given DT node's port and endpoint number
 87 *
 88 * Returns zero if successful, or one of the standard error codes if it fails.
 89 */
 90static inline int drm_of_panel_bridge_remove(const struct device_node *np,
 91					     int port, int endpoint)
 92{
 93#if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_DRM_PANEL_BRIDGE)
 94	struct drm_bridge *bridge;
 95	struct device_node *remote;
 96
 97	remote = of_graph_get_remote_node(np, port, endpoint);
 98	if (!remote)
 99		return -ENODEV;
100
101	bridge = of_drm_find_bridge(remote);
102	drm_panel_bridge_remove(bridge);
103
104	return 0;
105#else
106	return -EINVAL;
107#endif
108}
109
110static inline int drm_of_encoder_active_endpoint_id(struct device_node *node,
111						    struct drm_encoder *encoder)
112{
113	struct of_endpoint endpoint;
114	int ret = drm_of_encoder_active_endpoint(node, encoder,
115						 &endpoint);
116
117	return ret ?: endpoint.id;
118}
119
120static inline int drm_of_encoder_active_port_id(struct device_node *node,
121						struct drm_encoder *encoder)
122{
123	struct of_endpoint endpoint;
124	int ret = drm_of_encoder_active_endpoint(node, encoder,
125						 &endpoint);
126
127	return ret ?: endpoint.port;
128}
129
130#endif /* __DRM_OF_H__ */

 
 1#ifndef __DRM_OF_H__
 2#define __DRM_OF_H__
 3
 4#include <linux/of_graph.h>
 
 
 
 5
 6struct component_master_ops;
 
 7struct device;
 8struct drm_device;
 9struct drm_encoder;
 
 
10struct device_node;
11
12#ifdef CONFIG_OF
13extern uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
14					   struct device_node *port);
15extern int drm_of_component_probe(struct device *dev,
16				  int (*compare_of)(struct device *, void *),
17				  const struct component_master_ops *m_ops);
18extern int drm_of_encoder_active_endpoint(struct device_node *node,
19					  struct drm_encoder *encoder,
20					  struct of_endpoint *endpoint);
 
 
 
 
 
 
 
 
 
 
21#else
 
 
 
 
 
 
22static inline uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
23						  struct device_node *port)
24{
25	return 0;
26}
27
 
 
 
 
 
 
 
 
28static inline int
29drm_of_component_probe(struct device *dev,
30		       int (*compare_of)(struct device *, void *),
31		       const struct component_master_ops *m_ops)
32{
33	return -EINVAL;
34}
35
36static inline int drm_of_encoder_active_endpoint(struct device_node *node,
37						 struct drm_encoder *encoder,
38						 struct of_endpoint *endpoint)
39{
40	return -EINVAL;
41}
 
 
 
 
 
 
 
42#endif
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
43
44static inline int drm_of_encoder_active_endpoint_id(struct device_node *node,
45						    struct drm_encoder *encoder)
46{
47	struct of_endpoint endpoint;
48	int ret = drm_of_encoder_active_endpoint(node, encoder,
49						 &endpoint);
50
51	return ret ?: endpoint.id;
52}
53
54static inline int drm_of_encoder_active_port_id(struct device_node *node,
55						struct drm_encoder *encoder)
56{
57	struct of_endpoint endpoint;
58	int ret = drm_of_encoder_active_endpoint(node, encoder,
59						 &endpoint);
60
61	return ret ?: endpoint.port;
62}
63
64#endif /* __DRM_OF_H__ */