drivers/gpu/drm/omapdrm/dss/base.c

   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 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 && (dssdev->next || dssdev->bridge))
 153                         goto done;
 154         }
 155
 156         dssdev = NULL;
 157
 158 done:
 159         if (from)
 160                 omapdss_device_put(from);
 161         if (dssdev)
 162                 omapdss_device_get(dssdev);
 163
 164         mutex_unlock(&omapdss_devices_lock);
 165         return dssdev;
 166 }
 167 EXPORT_SYMBOL(omapdss_device_next_output);
 168
 169 static bool omapdss_device_is_connected(struct omap_dss_device *dssdev)
 170 {
 171         return dssdev->dss;
 172 }
 173
 174 int omapdss_device_connect(struct dss_device *dss,
 175                            struct omap_dss_device *src,
 176                            struct omap_dss_device *dst)
 177 {
 178         int ret;
 179
 180         dev_dbg(&dss->pdev->dev, "connect(%s, %s)\n",
 181                 src ? dev_name(src->dev) : "NULL",
 182                 dst ? dev_name(dst->dev) : "NULL");
 183
 184         if (!dst) {
 185                 /*
 186                  * The destination is NULL when the source is connected to a
 187                  * bridge instead of a DSS device. Stop here, we will attach
 188                  * the bridge later when we will have a DRM encoder.
 189                  */
 190                 return src && src->bridge ? 0 : -EINVAL;
 191         }
 192
 193         if (omapdss_device_is_connected(dst))
 194                 return -EBUSY;
 195
 196         dst->dss = dss;
 197
 198         if (dst->ops && dst->ops->connect) {
 199                 ret = dst->ops->connect(src, dst);
 200                 if (ret < 0) {
 201                         dst->dss = NULL;
 202                         return ret;
 203                 }
 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);
 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         if (dst->ops && dst->ops->disconnect)
 232                 dst->ops->disconnect(src, dst);
 233         dst->dss = NULL;
 234 }
 235 EXPORT_SYMBOL_GPL(omapdss_device_disconnect);
 236
 237 void omapdss_device_enable(struct omap_dss_device *dssdev)
 238 {
 239         if (!dssdev)
 240                 return;
 241
 242         if (dssdev->ops && dssdev->ops->enable)
 243                 dssdev->ops->enable(dssdev);
 244
 245         omapdss_device_enable(dssdev->next);
 246
 247         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 248 }
 249 EXPORT_SYMBOL_GPL(omapdss_device_enable);
 250
 251 void omapdss_device_disable(struct omap_dss_device *dssdev)
 252 {
 253         if (!dssdev)
 254                 return;
 255
 256         omapdss_device_disable(dssdev->next);
 257
 258         if (dssdev->ops && dssdev->ops->disable)
 259                 dssdev->ops->disable(dssdev);
 260 }
 261 EXPORT_SYMBOL_GPL(omapdss_device_disable);
 262
 263 /* -----------------------------------------------------------------------------
 264  * Components Handling
 265  */
 266
 267 static struct list_head omapdss_comp_list;
 268
 269 struct omapdss_comp_node {
 270         struct list_head list;
 271         struct device_node *node;
 272         bool dss_core_component;
 273         const char *compat;
 274 };
 275
 276 static bool omapdss_list_contains(const struct device_node *node)
 277 {
 278         struct omapdss_comp_node *comp;
 279
 280         list_for_each_entry(comp, &omapdss_comp_list, list) {
 281                 if (comp->node == node)
 282                         return true;
 283         }
 284
 285         return false;
 286 }
 287
 288 static void omapdss_walk_device(struct device *dev, struct device_node *node,
 289                                 bool dss_core)
 290 {
 291         struct omapdss_comp_node *comp;
 292         struct device_node *n;
 293         const char *compat;
 294         int ret;
 295
 296         ret = of_property_read_string(node, "compatible", &compat);
 297         if (ret < 0)
 298                 return;
 299
 300         comp = devm_kzalloc(dev, sizeof(*comp), GFP_KERNEL);
 301         if (comp) {
 302                 comp->node = node;
 303                 comp->dss_core_component = dss_core;
 304                 comp->compat = compat;
 305                 list_add(&comp->list, &omapdss_comp_list);
 306         }
 307
 308         /*
 309          * of_graph_get_remote_port_parent() prints an error if there is no
 310          * port/ports node. To avoid that, check first that there's the node.
 311          */
 312         n = of_get_child_by_name(node, "ports");
 313         if (!n)
 314                 n = of_get_child_by_name(node, "port");
 315         if (!n)
 316                 return;
 317
 318         of_node_put(n);
 319
 320         n = NULL;
 321         while ((n = of_graph_get_next_endpoint(node, n)) != NULL) {
 322                 struct device_node *pn = of_graph_get_remote_port_parent(n);
 323
 324                 if (!pn)
 325                         continue;
 326
 327                 if (!of_device_is_available(pn) || omapdss_list_contains(pn)) {
 328                         of_node_put(pn);
 329                         continue;
 330                 }
 331
 332                 omapdss_walk_device(dev, pn, false);
 333         }
 334 }
 335
 336 void omapdss_gather_components(struct device *dev)
 337 {
 338         struct device_node *child;
 339
 340         INIT_LIST_HEAD(&omapdss_comp_list);
 341
 342         omapdss_walk_device(dev, dev->of_node, true);
 343
 344         for_each_available_child_of_node(dev->of_node, child)
 345                 omapdss_walk_device(dev, child, true);
 346 }
 347 EXPORT_SYMBOL(omapdss_gather_components);
 348
 349 static bool omapdss_component_is_loaded(struct omapdss_comp_node *comp)
 350 {
 351         if (comp->dss_core_component)
 352                 return true;
 353         if (!strstarts(comp->compat, "omapdss,"))
 354                 return true;
 355         if (omapdss_device_is_registered(comp->node))
 356                 return true;
 357
 358         return false;
 359 }
 360
 361 bool omapdss_stack_is_ready(void)
 362 {
 363         struct omapdss_comp_node *comp;
 364
 365         list_for_each_entry(comp, &omapdss_comp_list, list) {
 366                 if (!omapdss_component_is_loaded(comp))
 367                         return false;
 368         }
 369
 370         return true;
 371 }
 372 EXPORT_SYMBOL(omapdss_stack_is_ready);
 373
 374 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
 375 MODULE_DESCRIPTION("OMAP Display Subsystem Base");
 376 MODULE_LICENSE("GPL v2");