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 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 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 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 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 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 71 void omapdss_device_put(struct omap_dss_device *dssdev) 72 { 73 put_device(dssdev->dev); 74 } 75 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 */ 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 136 static bool omapdss_device_is_connected(struct omap_dss_device *dssdev) 137 { 138 return dssdev->dss; 139 } 140 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 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 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 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 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 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 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