drivers/gpu/drm/drm_of.c

   1 #include <linux/component.h>
   2 #include <linux/export.h>
   3 #include <linux/list.h>
   4 #include <linux/of_graph.h>
   5 #include <drm/drmP.h>
   6 #include <drm/drm_bridge.h>
   7 #include <drm/drm_crtc.h>
   8 #include <drm/drm_encoder.h>
   9 #include <drm/drm_panel.h>
  10 #include <drm/drm_of.h>
  11
  12 /**
  13  * DOC: overview
  14  *
  15  * A set of helper functions to aid DRM drivers in parsing standard DT
  16  * properties.
  17  */
  18
  19 static void drm_release_of(struct device *dev, void *data)
  20 {
  21         of_node_put(data);
  22 }
  23
  24 /**
  25  * drm_of_crtc_port_mask - find the mask of a registered CRTC by port OF node
  26  * @dev: DRM device
  27  * @port: port OF node
  28  *
  29  * Given a port OF node, return the possible mask of the corresponding
  30  * CRTC within a device's list of CRTCs.  Returns zero if not found.
  31  */
  32 uint32_t drm_of_crtc_port_mask(struct drm_device *dev,
  33                             struct device_node *port)
  34 {
  35         unsigned int index = 0;
  36         struct drm_crtc *tmp;
  37
  38         drm_for_each_crtc(tmp, dev) {
  39                 if (tmp->port == port)
  40                         return 1 << index;
  41
  42                 index++;
  43         }
  44
  45         return 0;
  46 }
  47 EXPORT_SYMBOL(drm_of_crtc_port_mask);
  48
  49 /**
  50  * drm_of_find_possible_crtcs - find the possible CRTCs for an encoder port
  51  * @dev: DRM device
  52  * @port: encoder port to scan for endpoints
  53  *
  54  * Scan all endpoints attached to a port, locate their attached CRTCs,
  55  * and generate the DRM mask of CRTCs which may be attached to this
  56  * encoder.
  57  *
  58  * See Documentation/devicetree/bindings/graph.txt for the bindings.
  59  */
  60 uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
  61                                     struct device_node *port)
  62 {
  63         struct device_node *remote_port, *ep;
  64         uint32_t possible_crtcs = 0;
  65
  66         for_each_endpoint_of_node(port, ep) {
  67                 remote_port = of_graph_get_remote_port(ep);
  68                 if (!remote_port) {
  69                         of_node_put(ep);
  70                         return 0;
  71                 }
  72
  73                 possible_crtcs |= drm_of_crtc_port_mask(dev, remote_port);
  74
  75                 of_node_put(remote_port);
  76         }
  77
  78         return possible_crtcs;
  79 }
  80 EXPORT_SYMBOL(drm_of_find_possible_crtcs);
  81
  82 /**
  83  * drm_of_component_match_add - Add a component helper OF node match rule
  84  * @master: master device
  85  * @matchptr: component match pointer
  86  * @compare: compare function used for matching component
  87  * @node: of_node
  88  */
  89 void drm_of_component_match_add(struct device *master,
  90                                 struct component_match **matchptr,
  91                                 int (*compare)(struct device *, void *),
  92                                 struct device_node *node)
  93 {
  94         of_node_get(node);
  95         component_match_add_release(master, matchptr, drm_release_of,
  96                                     compare, node);
  97 }
  98 EXPORT_SYMBOL_GPL(drm_of_component_match_add);
  99
 100 /**
 101  * drm_of_component_probe - Generic probe function for a component based master
 102  * @dev: master device containing the OF node
 103  * @compare_of: compare function used for matching components
 104  * @m_ops: component master ops to be used
 105  *
 106  * Parse the platform device OF node and bind all the components associated
 107  * with the master. Interface ports are added before the encoders in order to
 108  * satisfy their .bind requirements
 109  * See Documentation/devicetree/bindings/graph.txt for the bindings.
 110  *
 111  * Returns zero if successful, or one of the standard error codes if it fails.
 112  */
 113 int drm_of_component_probe(struct device *dev,
 114                            int (*compare_of)(struct device *, void *),
 115                            const struct component_master_ops *m_ops)
 116 {
 117         struct device_node *ep, *port, *remote;
 118         struct component_match *match = NULL;
 119         int i;
 120
 121         if (!dev->of_node)
 122                 return -EINVAL;
 123
 124         /*
 125          * Bind the crtc's ports first, so that drm_of_find_possible_crtcs()
 126          * called from encoder's .bind callbacks works as expected
 127          */
 128         for (i = 0; ; i++) {
 129                 port = of_parse_phandle(dev->of_node, "ports", i);
 130                 if (!port)
 131                         break;
 132
 133                 if (of_device_is_available(port->parent))
 134                         drm_of_component_match_add(dev, &match, compare_of,
 135                                                    port);
 136
 137                 of_node_put(port);
 138         }
 139
 140         if (i == 0) {
 141                 dev_err(dev, "missing 'ports' property\n");
 142                 return -ENODEV;
 143         }
 144
 145         if (!match) {
 146                 dev_err(dev, "no available port\n");
 147                 return -ENODEV;
 148         }
 149
 150         /*
 151          * For bound crtcs, bind the encoders attached to their remote endpoint
 152          */
 153         for (i = 0; ; i++) {
 154                 port = of_parse_phandle(dev->of_node, "ports", i);
 155                 if (!port)
 156                         break;
 157
 158                 if (!of_device_is_available(port->parent)) {
 159                         of_node_put(port);
 160                         continue;
 161                 }
 162
 163                 for_each_child_of_node(port, ep) {
 164                         remote = of_graph_get_remote_port_parent(ep);
 165                         if (!remote || !of_device_is_available(remote)) {
 166                                 of_node_put(remote);
 167                                 continue;
 168                         } else if (!of_device_is_available(remote->parent)) {
 169                                 dev_warn(dev, "parent device of %pOF is not available\n",
 170                                          remote);
 171                                 of_node_put(remote);
 172                                 continue;
 173                         }
 174
 175                         drm_of_component_match_add(dev, &match, compare_of,
 176                                                    remote);
 177                         of_node_put(remote);
 178                 }
 179                 of_node_put(port);
 180         }
 181
 182         return component_master_add_with_match(dev, m_ops, match);
 183 }
 184 EXPORT_SYMBOL(drm_of_component_probe);
 185
 186 /*
 187  * drm_of_encoder_active_endpoint - return the active encoder endpoint
 188  * @node: device tree node containing encoder input ports
 189  * @encoder: drm_encoder
 190  *
 191  * Given an encoder device node and a drm_encoder with a connected crtc,
 192  * parse the encoder endpoint connecting to the crtc port.
 193  */
 194 int drm_of_encoder_active_endpoint(struct device_node *node,
 195                                    struct drm_encoder *encoder,
 196                                    struct of_endpoint *endpoint)
 197 {
 198         struct device_node *ep;
 199         struct drm_crtc *crtc = encoder->crtc;
 200         struct device_node *port;
 201         int ret;
 202
 203         if (!node || !crtc)
 204                 return -EINVAL;
 205
 206         for_each_endpoint_of_node(node, ep) {
 207                 port = of_graph_get_remote_port(ep);
 208                 of_node_put(port);
 209                 if (port == crtc->port) {
 210                         ret = of_graph_parse_endpoint(ep, endpoint);
 211                         of_node_put(ep);
 212                         return ret;
 213                 }
 214         }
 215
 216         return -EINVAL;
 217 }
 218 EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
 219
 220 /**
 221  * drm_of_find_panel_or_bridge - return connected panel or bridge device
 222  * @np: device tree node containing encoder output ports
 223  * @port: port in the device tree node
 224  * @endpoint: endpoint in the device tree node
 225  * @panel: pointer to hold returned drm_panel
 226  * @bridge: pointer to hold returned drm_bridge
 227  *
 228  * Given a DT node's port and endpoint number, find the connected node and
 229  * return either the associated struct drm_panel or drm_bridge device. Either
 230  * @panel or @bridge must not be NULL.
 231  *
 232  * Returns zero if successful, or one of the standard error codes if it fails.
 233  */
 234 int drm_of_find_panel_or_bridge(const struct device_node *np,
 235                                 int port, int endpoint,
 236                                 struct drm_panel **panel,
 237                                 struct drm_bridge **bridge)
 238 {
 239         int ret = -EPROBE_DEFER;
 240         struct device_node *remote;
 241
 242         if (!panel && !bridge)
 243                 return -EINVAL;
 244         if (panel)
 245                 *panel = NULL;
 246
 247         remote = of_graph_get_remote_node(np, port, endpoint);
 248         if (!remote)
 249                 return -ENODEV;
 250
 251         if (!of_device_is_available(remote)) {
 252                 of_node_put(remote);
 253                 return -ENODEV;
 254         }
 255
 256         if (panel) {
 257                 *panel = of_drm_find_panel(remote);
 258                 if (!IS_ERR(*panel))
 259                         ret = 0;
 260                 else
 261                         *panel = NULL;
 262         }
 263
 264         /* No panel found yet, check for a bridge next. */
 265         if (bridge) {
 266                 if (ret) {
 267                         *bridge = of_drm_find_bridge(remote);
 268                         if (*bridge)
 269                                 ret = 0;
 270                 } else {
 271                         *bridge = NULL;
 272                 }
 273
 274         }
 275
 276         of_node_put(remote);
 277         return ret;
 278 }
 279 EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);