1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * OMAP Display Subsystem Base
4  *
5  * Copyright (C) 2015-2017 Texas Instruments Incorporated - https://www.ti.com/
6  */
7 
8 #include <linux/kernel.h>
9 #include <linux/list.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/of.h>
13 #include <linux/of_graph.h>
14 #include <linux/platform_device.h>
15 
16 #include "dss.h"
17 #include "omapdss.h"
18 
dispc_get_dispc(struct dss_device * dss)19 struct dispc_device *dispc_get_dispc(struct dss_device *dss)
20 {
21 	return dss->dispc;
22 }
23 
24 /* -----------------------------------------------------------------------------
25  * OMAP DSS Devices Handling
26  */
27 
28 static LIST_HEAD(omapdss_devices_list);
29 static DEFINE_MUTEX(omapdss_devices_lock);
30 
omapdss_device_register(struct omap_dss_device * dssdev)31 void omapdss_device_register(struct omap_dss_device *dssdev)
32 {
33 	mutex_lock(&omapdss_devices_lock);
34 	list_add_tail(&dssdev->list, &omapdss_devices_list);
35 	mutex_unlock(&omapdss_devices_lock);
36 }
37 
omapdss_device_unregister(struct omap_dss_device * dssdev)38 void omapdss_device_unregister(struct omap_dss_device *dssdev)
39 {
40 	mutex_lock(&omapdss_devices_lock);
41 	list_del(&dssdev->list);
42 	mutex_unlock(&omapdss_devices_lock);
43 }
44 
omapdss_device_is_registered(struct device_node * node)45 static bool omapdss_device_is_registered(struct device_node *node)
46 {
47 	struct omap_dss_device *dssdev;
48 	bool found = false;
49 
50 	mutex_lock(&omapdss_devices_lock);
51 
52 	list_for_each_entry(dssdev, &omapdss_devices_list, list) {
53 		if (dssdev->dev->of_node == node) {
54 			found = true;
55 			break;
56 		}
57 	}
58 
59 	mutex_unlock(&omapdss_devices_lock);
60 	return found;
61 }
62 
omapdss_device_get(struct omap_dss_device * dssdev)63 struct omap_dss_device *omapdss_device_get(struct omap_dss_device *dssdev)
64 {
65 	if (get_device(dssdev->dev) == NULL)
66 		return NULL;
67 
68 	return dssdev;
69 }
70 
omapdss_device_put(struct omap_dss_device * dssdev)71 void omapdss_device_put(struct omap_dss_device *dssdev)
72 {
73 	put_device(dssdev->dev);
74 }
75 
omapdss_find_device_by_node(struct device_node * node)76 struct omap_dss_device *omapdss_find_device_by_node(struct device_node *node)
77 {
78 	struct omap_dss_device *dssdev;
79 
80 	list_for_each_entry(dssdev, &omapdss_devices_list, list) {
81 		if (dssdev->dev->of_node == node)
82 			return omapdss_device_get(dssdev);
83 	}
84 
85 	return NULL;
86 }
87 
88 /*
89  * Search for the next output device starting at @from. Release the reference to
90  * the @from device, and acquire a reference to the returned device if found.
91  */
omapdss_device_next_output(struct omap_dss_device * from)92 struct omap_dss_device *omapdss_device_next_output(struct omap_dss_device *from)
93 {
94 	struct omap_dss_device *dssdev;
95 	struct list_head *list;
96 
97 	mutex_lock(&omapdss_devices_lock);
98 
99 	if (list_empty(&omapdss_devices_list)) {
100 		dssdev = NULL;
101 		goto done;
102 	}
103 
104 	/*
105 	 * Start from the from entry if given or from omapdss_devices_list
106 	 * otherwise.
107 	 */
108 	list = from ? &from->list : &omapdss_devices_list;
109 
110 	list_for_each_entry(dssdev, list, list) {
111 		/*
112 		 * Stop if we reach the omapdss_devices_list, that's the end of
113 		 * the list.
114 		 */
115 		if (&dssdev->list == &omapdss_devices_list) {
116 			dssdev = NULL;
117 			goto done;
118 		}
119 
120 		if (dssdev->id && dssdev->bridge)
121 			goto done;
122 	}
123 
124 	dssdev = NULL;
125 
126 done:
127 	if (from)
128 		omapdss_device_put(from);
129 	if (dssdev)
130 		omapdss_device_get(dssdev);
131 
132 	mutex_unlock(&omapdss_devices_lock);
133 	return dssdev;
134 }
135 
omapdss_device_is_connected(struct omap_dss_device * dssdev)136 static bool omapdss_device_is_connected(struct omap_dss_device *dssdev)
137 {
138 	return dssdev->dss;
139 }
140 
omapdss_device_connect(struct dss_device * dss,struct omap_dss_device * src,struct omap_dss_device * dst)141 int omapdss_device_connect(struct dss_device *dss,
142 			   struct omap_dss_device *src,
143 			   struct omap_dss_device *dst)
144 {
145 	dev_dbg(&dss->pdev->dev, "connect(%s, %s)\n",
146 		src ? dev_name(src->dev) : "NULL",
147 		dst ? dev_name(dst->dev) : "NULL");
148 
149 	if (!dst) {
150 		/*
151 		 * The destination is NULL when the source is connected to a
152 		 * bridge instead of a DSS device. Stop here, we will attach
153 		 * the bridge later when we will have a DRM encoder.
154 		 */
155 		return src && src->bridge ? 0 : -EINVAL;
156 	}
157 
158 	if (omapdss_device_is_connected(dst))
159 		return -EBUSY;
160 
161 	dst->dss = dss;
162 
163 	return 0;
164 }
165 
omapdss_device_disconnect(struct omap_dss_device * src,struct omap_dss_device * dst)166 void omapdss_device_disconnect(struct omap_dss_device *src,
167 			       struct omap_dss_device *dst)
168 {
169 	struct dss_device *dss = src ? src->dss : dst->dss;
170 
171 	dev_dbg(&dss->pdev->dev, "disconnect(%s, %s)\n",
172 		src ? dev_name(src->dev) : "NULL",
173 		dst ? dev_name(dst->dev) : "NULL");
174 
175 	if (!dst) {
176 		WARN_ON(!src->bridge);
177 		return;
178 	}
179 
180 	if (!dst->id && !omapdss_device_is_connected(dst)) {
181 		WARN_ON(1);
182 		return;
183 	}
184 
185 	dst->dss = NULL;
186 }
187 
188 /* -----------------------------------------------------------------------------
189  * Components Handling
190  */
191 
192 static struct list_head omapdss_comp_list;
193 
194 struct omapdss_comp_node {
195 	struct list_head list;
196 	struct device_node *node;
197 	bool dss_core_component;
198 	const char *compat;
199 };
200 
omapdss_list_contains(const struct device_node * node)201 static bool omapdss_list_contains(const struct device_node *node)
202 {
203 	struct omapdss_comp_node *comp;
204 
205 	list_for_each_entry(comp, &omapdss_comp_list, list) {
206 		if (comp->node == node)
207 			return true;
208 	}
209 
210 	return false;
211 }
212 
omapdss_walk_device(struct device * dev,struct device_node * node,bool dss_core)213 static void omapdss_walk_device(struct device *dev, struct device_node *node,
214 				bool dss_core)
215 {
216 	struct omapdss_comp_node *comp;
217 	struct device_node *n;
218 	const char *compat;
219 	int ret;
220 
221 	ret = of_property_read_string(node, "compatible", &compat);
222 	if (ret < 0)
223 		return;
224 
225 	comp = devm_kzalloc(dev, sizeof(*comp), GFP_KERNEL);
226 	if (comp) {
227 		comp->node = node;
228 		comp->dss_core_component = dss_core;
229 		comp->compat = compat;
230 		list_add(&comp->list, &omapdss_comp_list);
231 	}
232 
233 	/*
234 	 * of_graph_get_remote_port_parent() prints an error if there is no
235 	 * port/ports node. To avoid that, check first that there's the node.
236 	 */
237 	n = of_get_child_by_name(node, "ports");
238 	if (!n)
239 		n = of_get_child_by_name(node, "port");
240 	if (!n)
241 		return;
242 
243 	of_node_put(n);
244 
245 	n = NULL;
246 	while ((n = of_graph_get_next_endpoint(node, n)) != NULL) {
247 		struct device_node *pn = of_graph_get_remote_port_parent(n);
248 
249 		if (!pn)
250 			continue;
251 
252 		if (!of_device_is_available(pn) || omapdss_list_contains(pn)) {
253 			of_node_put(pn);
254 			continue;
255 		}
256 
257 		omapdss_walk_device(dev, pn, false);
258 	}
259 }
260 
omapdss_gather_components(struct device * dev)261 void omapdss_gather_components(struct device *dev)
262 {
263 	struct device_node *child;
264 
265 	INIT_LIST_HEAD(&omapdss_comp_list);
266 
267 	omapdss_walk_device(dev, dev->of_node, true);
268 
269 	for_each_available_child_of_node(dev->of_node, child)
270 		omapdss_walk_device(dev, child, true);
271 }
272 
omapdss_component_is_loaded(struct omapdss_comp_node * comp)273 static bool omapdss_component_is_loaded(struct omapdss_comp_node *comp)
274 {
275 	if (comp->dss_core_component)
276 		return true;
277 	if (!strstarts(comp->compat, "omapdss,"))
278 		return true;
279 	if (omapdss_device_is_registered(comp->node))
280 		return true;
281 
282 	return false;
283 }
284 
omapdss_stack_is_ready(void)285 bool omapdss_stack_is_ready(void)
286 {
287 	struct omapdss_comp_node *comp;
288 
289 	list_for_each_entry(comp, &omapdss_comp_list, list) {
290 		if (!omapdss_component_is_loaded(comp))
291 			return false;
292 	}
293 
294 	return true;
295 }
296