1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * OMAP Display Subsystem Base 4 * 5 * Copyright (C) 2015-2017 Texas Instruments Incorporated - http://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 static struct dss_device *dss_device; 20 21 struct dss_device *omapdss_get_dss(void) 22 { 23 return dss_device; 24 } 25 EXPORT_SYMBOL(omapdss_get_dss); 26 27 void omapdss_set_dss(struct dss_device *dss) 28 { 29 dss_device = dss; 30 } 31 EXPORT_SYMBOL(omapdss_set_dss); 32 33 struct dispc_device *dispc_get_dispc(struct dss_device *dss) 34 { 35 return dss->dispc; 36 } 37 EXPORT_SYMBOL(dispc_get_dispc); 38 39 const struct dispc_ops *dispc_get_ops(struct dss_device *dss) 40 { 41 return dss->dispc_ops; 42 } 43 EXPORT_SYMBOL(dispc_get_ops); 44 45 46 /* ----------------------------------------------------------------------------- 47 * OMAP DSS Devices Handling 48 */ 49 50 static LIST_HEAD(omapdss_devices_list); 51 static DEFINE_MUTEX(omapdss_devices_lock); 52 53 void omapdss_device_register(struct omap_dss_device *dssdev) 54 { 55 mutex_lock(&omapdss_devices_lock); 56 list_add_tail(&dssdev->list, &omapdss_devices_list); 57 mutex_unlock(&omapdss_devices_lock); 58 } 59 EXPORT_SYMBOL_GPL(omapdss_device_register); 60 61 void omapdss_device_unregister(struct omap_dss_device *dssdev) 62 { 63 mutex_lock(&omapdss_devices_lock); 64 list_del(&dssdev->list); 65 mutex_unlock(&omapdss_devices_lock); 66 } 67 EXPORT_SYMBOL_GPL(omapdss_device_unregister); 68 69 static bool omapdss_device_is_registered(struct device_node *node) 70 { 71 struct omap_dss_device *dssdev; 72 bool found = false; 73 74 mutex_lock(&omapdss_devices_lock); 75 76 list_for_each_entry(dssdev, &omapdss_devices_list, list) { 77 if (dssdev->dev->of_node == node) { 78 found = true; 79 break; 80 } 81 } 82 83 mutex_unlock(&omapdss_devices_lock); 84 return found; 85 } 86 87 struct omap_dss_device *omapdss_device_get(struct omap_dss_device *dssdev) 88 { 89 if (!try_module_get(dssdev->owner)) 90 return NULL; 91 92 if (get_device(dssdev->dev) == NULL) { 93 module_put(dssdev->owner); 94 return NULL; 95 } 96 97 return dssdev; 98 } 99 EXPORT_SYMBOL(omapdss_device_get); 100 101 void omapdss_device_put(struct omap_dss_device *dssdev) 102 { 103 put_device(dssdev->dev); 104 module_put(dssdev->owner); 105 } 106 EXPORT_SYMBOL(omapdss_device_put); 107 108 struct omap_dss_device *omapdss_find_device_by_node(struct device_node *node) 109 { 110 struct omap_dss_device *dssdev; 111 112 list_for_each_entry(dssdev, &omapdss_devices_list, list) { 113 if (dssdev->dev->of_node == node) 114 return omapdss_device_get(dssdev); 115 } 116 117 return NULL; 118 } 119 120 /* 121 * Search for the next output device starting at @from. Release the reference to 122 * the @from device, and acquire a reference to the returned device if found. 123 */ 124 struct omap_dss_device *omapdss_device_next_output(struct omap_dss_device *from) 125 { 126 struct omap_dss_device *dssdev; 127 struct list_head *list; 128 129 mutex_lock(&omapdss_devices_lock); 130 131 if (list_empty(&omapdss_devices_list)) { 132 dssdev = NULL; 133 goto done; 134 } 135 136 /* 137 * Start from the from entry if given or from omapdss_devices_list 138 * otherwise. 139 */ 140 list = from ? &from->list : &omapdss_devices_list; 141 142 list_for_each_entry(dssdev, list, list) { 143 /* 144 * Stop if we reach the omapdss_devices_list, that's the end of 145 * the list. 146 */ 147 if (&dssdev->list == &omapdss_devices_list) { 148 dssdev = NULL; 149 goto done; 150 } 151 152 if (dssdev->id && 153 (dssdev->next || dssdev->bridge || dssdev->panel)) 154 goto done; 155 } 156 157 dssdev = NULL; 158 159 done: 160 if (from) 161 omapdss_device_put(from); 162 if (dssdev) 163 omapdss_device_get(dssdev); 164 165 mutex_unlock(&omapdss_devices_lock); 166 return dssdev; 167 } 168 EXPORT_SYMBOL(omapdss_device_next_output); 169 170 static bool omapdss_device_is_connected(struct omap_dss_device *dssdev) 171 { 172 return dssdev->dss; 173 } 174 175 int omapdss_device_connect(struct dss_device *dss, 176 struct omap_dss_device *src, 177 struct omap_dss_device *dst) 178 { 179 int ret; 180 181 dev_dbg(&dss->pdev->dev, "connect(%s, %s)\n", 182 src ? dev_name(src->dev) : "NULL", 183 dst ? dev_name(dst->dev) : "NULL"); 184 185 if (!dst) { 186 /* 187 * The destination is NULL when the source is connected to a 188 * bridge or panel instead of a DSS device. Stop here, we will 189 * attach the bridge or panel later when we will have a DRM 190 * encoder. 191 */ 192 return src && (src->bridge || src->panel) ? 0 : -EINVAL; 193 } 194 195 if (omapdss_device_is_connected(dst)) 196 return -EBUSY; 197 198 dst->dss = dss; 199 200 ret = dst->ops->connect(src, dst); 201 if (ret < 0) { 202 dst->dss = NULL; 203 return ret; 204 } 205 206 return 0; 207 } 208 EXPORT_SYMBOL_GPL(omapdss_device_connect); 209 210 void omapdss_device_disconnect(struct omap_dss_device *src, 211 struct omap_dss_device *dst) 212 { 213 struct dss_device *dss = src ? src->dss : dst->dss; 214 215 dev_dbg(&dss->pdev->dev, "disconnect(%s, %s)\n", 216 src ? dev_name(src->dev) : "NULL", 217 dst ? dev_name(dst->dev) : "NULL"); 218 219 if (!dst) { 220 WARN_ON(!src->bridge && !src->panel); 221 return; 222 } 223 224 if (!dst->id && !omapdss_device_is_connected(dst)) { 225 WARN_ON(!dst->display); 226 return; 227 } 228 229 WARN_ON(dst->state != OMAP_DSS_DISPLAY_DISABLED); 230 231 dst->ops->disconnect(src, dst); 232 dst->dss = NULL; 233 } 234 EXPORT_SYMBOL_GPL(omapdss_device_disconnect); 235 236 void omapdss_device_pre_enable(struct omap_dss_device *dssdev) 237 { 238 if (!dssdev) 239 return; 240 241 omapdss_device_pre_enable(dssdev->next); 242 243 if (dssdev->ops->pre_enable) 244 dssdev->ops->pre_enable(dssdev); 245 } 246 EXPORT_SYMBOL_GPL(omapdss_device_pre_enable); 247 248 void omapdss_device_enable(struct omap_dss_device *dssdev) 249 { 250 if (!dssdev) 251 return; 252 253 if (dssdev->ops->enable) 254 dssdev->ops->enable(dssdev); 255 256 omapdss_device_enable(dssdev->next); 257 258 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; 259 } 260 EXPORT_SYMBOL_GPL(omapdss_device_enable); 261 262 void omapdss_device_disable(struct omap_dss_device *dssdev) 263 { 264 if (!dssdev) 265 return; 266 267 omapdss_device_disable(dssdev->next); 268 269 if (dssdev->ops->disable) 270 dssdev->ops->disable(dssdev); 271 } 272 EXPORT_SYMBOL_GPL(omapdss_device_disable); 273 274 void omapdss_device_post_disable(struct omap_dss_device *dssdev) 275 { 276 if (!dssdev) 277 return; 278 279 if (dssdev->ops->post_disable) 280 dssdev->ops->post_disable(dssdev); 281 282 omapdss_device_post_disable(dssdev->next); 283 284 dssdev->state = OMAP_DSS_DISPLAY_DISABLED; 285 } 286 EXPORT_SYMBOL_GPL(omapdss_device_post_disable); 287 288 /* ----------------------------------------------------------------------------- 289 * Components Handling 290 */ 291 292 static struct list_head omapdss_comp_list; 293 294 struct omapdss_comp_node { 295 struct list_head list; 296 struct device_node *node; 297 bool dss_core_component; 298 const char *compat; 299 }; 300 301 static bool omapdss_list_contains(const struct device_node *node) 302 { 303 struct omapdss_comp_node *comp; 304 305 list_for_each_entry(comp, &omapdss_comp_list, list) { 306 if (comp->node == node) 307 return true; 308 } 309 310 return false; 311 } 312 313 static void omapdss_walk_device(struct device *dev, struct device_node *node, 314 bool dss_core) 315 { 316 struct omapdss_comp_node *comp; 317 struct device_node *n; 318 const char *compat; 319 int ret; 320 321 ret = of_property_read_string(node, "compatible", &compat); 322 if (ret < 0) 323 return; 324 325 comp = devm_kzalloc(dev, sizeof(*comp), GFP_KERNEL); 326 if (comp) { 327 comp->node = node; 328 comp->dss_core_component = dss_core; 329 comp->compat = compat; 330 list_add(&comp->list, &omapdss_comp_list); 331 } 332 333 /* 334 * of_graph_get_remote_port_parent() prints an error if there is no 335 * port/ports node. To avoid that, check first that there's the node. 336 */ 337 n = of_get_child_by_name(node, "ports"); 338 if (!n) 339 n = of_get_child_by_name(node, "port"); 340 if (!n) 341 return; 342 343 of_node_put(n); 344 345 n = NULL; 346 while ((n = of_graph_get_next_endpoint(node, n)) != NULL) { 347 struct device_node *pn = of_graph_get_remote_port_parent(n); 348 349 if (!pn) 350 continue; 351 352 if (!of_device_is_available(pn) || omapdss_list_contains(pn)) { 353 of_node_put(pn); 354 continue; 355 } 356 357 omapdss_walk_device(dev, pn, false); 358 } 359 } 360 361 void omapdss_gather_components(struct device *dev) 362 { 363 struct device_node *child; 364 365 INIT_LIST_HEAD(&omapdss_comp_list); 366 367 omapdss_walk_device(dev, dev->of_node, true); 368 369 for_each_available_child_of_node(dev->of_node, child) 370 omapdss_walk_device(dev, child, true); 371 } 372 EXPORT_SYMBOL(omapdss_gather_components); 373 374 static bool omapdss_component_is_loaded(struct omapdss_comp_node *comp) 375 { 376 if (comp->dss_core_component) 377 return true; 378 if (!strstarts(comp->compat, "omapdss,")) 379 return true; 380 if (omapdss_device_is_registered(comp->node)) 381 return true; 382 383 return false; 384 } 385 386 bool omapdss_stack_is_ready(void) 387 { 388 struct omapdss_comp_node *comp; 389 390 list_for_each_entry(comp, &omapdss_comp_list, list) { 391 if (!omapdss_component_is_loaded(comp)) 392 return false; 393 } 394 395 return true; 396 } 397 EXPORT_SYMBOL(omapdss_stack_is_ready); 398 399 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>"); 400 MODULE_DESCRIPTION("OMAP Display Subsystem Base"); 401 MODULE_LICENSE("GPL v2"); 402