drivers/gpu/drm/drm_of.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/component.h>
   3 #include <linux/export.h>
   4 #include <linux/list.h>
   5 #include <linux/of_graph.h>
   6
   7 #include <drm/drm_bridge.h>
   8 #include <drm/drm_crtc.h>
   9 #include <drm/drm_device.h>
  10 #include <drm/drm_encoder.h>
  11 #include <drm/drm_of.h>
  12 #include <drm/drm_panel.h>
  13
  14 /**
  15  * DOC: overview
  16  *
  17  * A set of helper functions to aid DRM drivers in parsing standard DT
  18  * properties.
  19  */
  20
  21 static void drm_release_of(struct device *dev, void *data)
  22 {
  23         of_node_put(data);
  24 }
  25
  26 /**
  27  * drm_of_crtc_port_mask - find the mask of a registered CRTC by port OF node
  28  * @dev: DRM device
  29  * @port: port OF node
  30  *
  31  * Given a port OF node, return the possible mask of the corresponding
  32  * CRTC within a device's list of CRTCs.  Returns zero if not found.
  33  */
  34 uint32_t drm_of_crtc_port_mask(struct drm_device *dev,
  35                             struct device_node *port)
  36 {
  37         unsigned int index = 0;
  38         struct drm_crtc *tmp;
  39
  40         drm_for_each_crtc(tmp, dev) {
  41                 if (tmp->port == port)
  42                         return 1 << index;
  43
  44                 index++;
  45         }
  46
  47         return 0;
  48 }
  49 EXPORT_SYMBOL(drm_of_crtc_port_mask);
  50
  51 /**
  52  * drm_of_find_possible_crtcs - find the possible CRTCs for an encoder port
  53  * @dev: DRM device
  54  * @port: encoder port to scan for endpoints
  55  *
  56  * Scan all endpoints attached to a port, locate their attached CRTCs,
  57  * and generate the DRM mask of CRTCs which may be attached to this
  58  * encoder.
  59  *
  60  * See Documentation/devicetree/bindings/graph.txt for the bindings.
  61  */
  62 uint32_t drm_of_find_possible_crtcs(struct drm_device *dev,
  63                                     struct device_node *port)
  64 {
  65         struct device_node *remote_port, *ep;
  66         uint32_t possible_crtcs = 0;
  67
  68         for_each_endpoint_of_node(port, ep) {
  69                 remote_port = of_graph_get_remote_port(ep);
  70                 if (!remote_port) {
  71                         of_node_put(ep);
  72                         return 0;
  73                 }
  74
  75                 possible_crtcs |= drm_of_crtc_port_mask(dev, remote_port);
  76
  77                 of_node_put(remote_port);
  78         }
  79
  80         return possible_crtcs;
  81 }
  82 EXPORT_SYMBOL(drm_of_find_possible_crtcs);
  83
  84 /**
  85  * drm_of_component_match_add - Add a component helper OF node match rule
  86  * @master: master device
  87  * @matchptr: component match pointer
  88  * @compare: compare function used for matching component
  89  * @node: of_node
  90  */
  91 void drm_of_component_match_add(struct device *master,
  92                                 struct component_match **matchptr,
  93                                 int (*compare)(struct device *, void *),
  94                                 struct device_node *node)
  95 {
  96         of_node_get(node);
  97         component_match_add_release(master, matchptr, drm_release_of,
  98                                     compare, node);
  99 }
 100 EXPORT_SYMBOL_GPL(drm_of_component_match_add);
 101
 102 /**
 103  * drm_of_component_probe - Generic probe function for a component based master
 104  * @dev: master device containing the OF node
 105  * @compare_of: compare function used for matching components
 106  * @m_ops: component master ops to be used
 107  *
 108  * Parse the platform device OF node and bind all the components associated
 109  * with the master. Interface ports are added before the encoders in order to
 110  * satisfy their .bind requirements
 111  * See Documentation/devicetree/bindings/graph.txt for the bindings.
 112  *
 113  * Returns zero if successful, or one of the standard error codes if it fails.
 114  */
 115 int drm_of_component_probe(struct device *dev,
 116                            int (*compare_of)(struct device *, void *),
 117                            const struct component_master_ops *m_ops)
 118 {
 119         struct device_node *ep, *port, *remote;
 120         struct component_match *match = NULL;
 121         int i;
 122
 123         if (!dev->of_node)
 124                 return -EINVAL;
 125
 126         /*
 127          * Bind the crtc's ports first, so that drm_of_find_possible_crtcs()
 128          * called from encoder's .bind callbacks works as expected
 129          */
 130         for (i = 0; ; i++) {
 131                 port = of_parse_phandle(dev->of_node, "ports", i);
 132                 if (!port)
 133                         break;
 134
 135                 if (of_device_is_available(port->parent))
 136                         drm_of_component_match_add(dev, &match, compare_of,
 137                                                    port);
 138
 139                 of_node_put(port);
 140         }
 141
 142         if (i == 0) {
 143                 dev_err(dev, "missing 'ports' property\n");
 144                 return -ENODEV;
 145         }
 146
 147         if (!match) {
 148                 dev_err(dev, "no available port\n");
 149                 return -ENODEV;
 150         }
 151
 152         /*
 153          * For bound crtcs, bind the encoders attached to their remote endpoint
 154          */
 155         for (i = 0; ; i++) {
 156                 port = of_parse_phandle(dev->of_node, "ports", i);
 157                 if (!port)
 158                         break;
 159
 160                 if (!of_device_is_available(port->parent)) {
 161                         of_node_put(port);
 162                         continue;
 163                 }
 164
 165                 for_each_child_of_node(port, ep) {
 166                         remote = of_graph_get_remote_port_parent(ep);
 167                         if (!remote || !of_device_is_available(remote)) {
 168                                 of_node_put(remote);
 169                                 continue;
 170                         } else if (!of_device_is_available(remote->parent)) {
 171                                 dev_warn(dev, "parent device of %pOF is not available\n",
 172                                          remote);
 173                                 of_node_put(remote);
 174                                 continue;
 175                         }
 176
 177                         drm_of_component_match_add(dev, &match, compare_of,
 178                                                    remote);
 179                         of_node_put(remote);
 180                 }
 181                 of_node_put(port);
 182         }
 183
 184         return component_master_add_with_match(dev, m_ops, match);
 185 }
 186 EXPORT_SYMBOL(drm_of_component_probe);
 187
 188 /*
 189  * drm_of_encoder_active_endpoint - return the active encoder endpoint
 190  * @node: device tree node containing encoder input ports
 191  * @encoder: drm_encoder
 192  *
 193  * Given an encoder device node and a drm_encoder with a connected crtc,
 194  * parse the encoder endpoint connecting to the crtc port.
 195  */
 196 int drm_of_encoder_active_endpoint(struct device_node *node,
 197                                    struct drm_encoder *encoder,
 198                                    struct of_endpoint *endpoint)
 199 {
 200         struct device_node *ep;
 201         struct drm_crtc *crtc = encoder->crtc;
 202         struct device_node *port;
 203         int ret;
 204
 205         if (!node || !crtc)
 206                 return -EINVAL;
 207
 208         for_each_endpoint_of_node(node, ep) {
 209                 port = of_graph_get_remote_port(ep);
 210                 of_node_put(port);
 211                 if (port == crtc->port) {
 212                         ret = of_graph_parse_endpoint(ep, endpoint);
 213                         of_node_put(ep);
 214                         return ret;
 215                 }
 216         }
 217
 218         return -EINVAL;
 219 }
 220 EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
 221
 222 /**
 223  * drm_of_find_panel_or_bridge - return connected panel or bridge device
 224  * @np: device tree node containing encoder output ports
 225  * @port: port in the device tree node
 226  * @endpoint: endpoint in the device tree node
 227  * @panel: pointer to hold returned drm_panel
 228  * @bridge: pointer to hold returned drm_bridge
 229  *
 230  * Given a DT node's port and endpoint number, find the connected node and
 231  * return either the associated struct drm_panel or drm_bridge device. Either
 232  * @panel or @bridge must not be NULL.
 233  *
 234  * This function is deprecated and should not be used in new drivers. Use
 235  * devm_drm_of_get_bridge() instead.
 236  *
 237  * Returns zero if successful, or one of the standard error codes if it fails.
 238  */
 239 int drm_of_find_panel_or_bridge(const struct device_node *np,
 240                                 int port, int endpoint,
 241                                 struct drm_panel **panel,
 242                                 struct drm_bridge **bridge)
 243 {
 244         int ret = -EPROBE_DEFER;
 245         struct device_node *remote;
 246
 247         if (!panel && !bridge)
 248                 return -EINVAL;
 249         if (panel)
 250                 *panel = NULL;
 251
 252         /**
 253          * Devices can also be child nodes when we also control that device
 254          * through the upstream device (ie, MIPI-DCS for a MIPI-DSI device).
 255          *
 256          * Lookup for a child node of the given parent that isn't either port
 257          * or ports.
 258          */
 259         for_each_available_child_of_node(np, remote) {
 260                 if (of_node_name_eq(remote, "port") ||
 261                     of_node_name_eq(remote, "ports"))
 262                         continue;
 263
 264                 goto of_find_panel_or_bridge;
 265         }
 266
 267         /*
 268          * of_graph_get_remote_node() produces a noisy error message if port
 269          * node isn't found and the absence of the port is a legit case here,
 270          * so at first we silently check whether graph presents in the
 271          * device-tree node.
 272          */
 273         if (!of_graph_is_present(np))
 274                 return -ENODEV;
 275
 276         remote = of_graph_get_remote_node(np, port, endpoint);
 277
 278 of_find_panel_or_bridge:
 279         if (!remote)
 280                 return -ENODEV;
 281
 282         if (panel) {
 283                 *panel = of_drm_find_panel(remote);
 284                 if (!IS_ERR(*panel))
 285                         ret = 0;
 286                 else
 287                         *panel = NULL;
 288         }
 289
 290         /* No panel found yet, check for a bridge next. */
 291         if (bridge) {
 292                 if (ret) {
 293                         *bridge = of_drm_find_bridge(remote);
 294                         if (*bridge)
 295                                 ret = 0;
 296                 } else {
 297                         *bridge = NULL;
 298                 }
 299
 300         }
 301
 302         of_node_put(remote);
 303         return ret;
 304 }
 305 EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);
 306
 307 enum drm_of_lvds_pixels {
 308         DRM_OF_LVDS_EVEN = BIT(0),
 309         DRM_OF_LVDS_ODD = BIT(1),
 310 };
 311
 312 static int drm_of_lvds_get_port_pixels_type(struct device_node *port_node)
 313 {
 314         bool even_pixels =
 315                 of_property_read_bool(port_node, "dual-lvds-even-pixels");
 316         bool odd_pixels =
 317                 of_property_read_bool(port_node, "dual-lvds-odd-pixels");
 318
 319         return (even_pixels ? DRM_OF_LVDS_EVEN : 0) |
 320                (odd_pixels ? DRM_OF_LVDS_ODD : 0);
 321 }
 322
 323 static int drm_of_lvds_get_remote_pixels_type(
 324                         const struct device_node *port_node)
 325 {
 326         struct device_node *endpoint = NULL;
 327         int pixels_type = -EPIPE;
 328
 329         for_each_child_of_node(port_node, endpoint) {
 330                 struct device_node *remote_port;
 331                 int current_pt;
 332
 333                 if (!of_node_name_eq(endpoint, "endpoint"))
 334                         continue;
 335
 336                 remote_port = of_graph_get_remote_port(endpoint);
 337                 if (!remote_port) {
 338                         of_node_put(endpoint);
 339                         return -EPIPE;
 340                 }
 341
 342                 current_pt = drm_of_lvds_get_port_pixels_type(remote_port);
 343                 of_node_put(remote_port);
 344                 if (pixels_type < 0)
 345                         pixels_type = current_pt;
 346
 347                 /*
 348                  * Sanity check, ensure that all remote endpoints have the same
 349                  * pixel type. We may lift this restriction later if we need to
 350                  * support multiple sinks with different dual-link
 351                  * configurations by passing the endpoints explicitly to
 352                  * drm_of_lvds_get_dual_link_pixel_order().
 353                  */
 354                 if (!current_pt || pixels_type != current_pt) {
 355                         of_node_put(endpoint);
 356                         return -EINVAL;
 357                 }
 358         }
 359
 360         return pixels_type;
 361 }
 362
 363 /**
 364  * drm_of_lvds_get_dual_link_pixel_order - Get LVDS dual-link pixel order
 365  * @port1: First DT port node of the Dual-link LVDS source
 366  * @port2: Second DT port node of the Dual-link LVDS source
 367  *
 368  * An LVDS dual-link connection is made of two links, with even pixels
 369  * transitting on one link, and odd pixels on the other link. This function
 370  * returns, for two ports of an LVDS dual-link source, which port shall transmit
 371  * the even and odd pixels, based on the requirements of the connected sink.
 372  *
 373  * The pixel order is determined from the dual-lvds-even-pixels and
 374  * dual-lvds-odd-pixels properties in the sink's DT port nodes. If those
 375  * properties are not present, or if their usage is not valid, this function
 376  * returns -EINVAL.
 377  *
 378  * If either port is not connected, this function returns -EPIPE.
 379  *
 380  * @port1 and @port2 are typically DT sibling nodes, but may have different
 381  * parents when, for instance, two separate LVDS encoders carry the even and odd
 382  * pixels.
 383  *
 384  * Return:
 385  * * DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS - @port1 carries even pixels and @port2
 386  *   carries odd pixels
 387  * * DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS - @port1 carries odd pixels and @port2
 388  *   carries even pixels
 389  * * -EINVAL - @port1 and @port2 are not connected to a dual-link LVDS sink, or
 390  *   the sink configuration is invalid
 391  * * -EPIPE - when @port1 or @port2 are not connected
 392  */
 393 int drm_of_lvds_get_dual_link_pixel_order(const struct device_node *port1,
 394                                           const struct device_node *port2)
 395 {
 396         int remote_p1_pt, remote_p2_pt;
 397
 398         if (!port1 || !port2)
 399                 return -EINVAL;
 400
 401         remote_p1_pt = drm_of_lvds_get_remote_pixels_type(port1);
 402         if (remote_p1_pt < 0)
 403                 return remote_p1_pt;
 404
 405         remote_p2_pt = drm_of_lvds_get_remote_pixels_type(port2);
 406         if (remote_p2_pt < 0)
 407                 return remote_p2_pt;
 408
 409         /*
 410          * A valid dual-lVDS bus is found when one remote port is marked with
 411          * "dual-lvds-even-pixels", and the other remote port is marked with
 412          * "dual-lvds-odd-pixels", bail out if the markers are not right.
 413          */
 414         if (remote_p1_pt + remote_p2_pt != DRM_OF_LVDS_EVEN + DRM_OF_LVDS_ODD)
 415                 return -EINVAL;
 416
 417         return remote_p1_pt == DRM_OF_LVDS_EVEN ?
 418                 DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS :
 419                 DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS;
 420 }
 421 EXPORT_SYMBOL_GPL(drm_of_lvds_get_dual_link_pixel_order);
 422
 423 /**
 424  * drm_of_lvds_get_data_mapping - Get LVDS data mapping
 425  * @port: DT port node of the LVDS source or sink
 426  *
 427  * Convert DT "data-mapping" property string value into media bus format value.
 428  *
 429  * Return:
 430  * * MEDIA_BUS_FMT_RGB666_1X7X3_SPWG - data-mapping is "jeida-18"
 431  * * MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA - data-mapping is "jeida-24"
 432  * * MEDIA_BUS_FMT_RGB888_1X7X4_SPWG - data-mapping is "vesa-24"
 433  * * -EINVAL - the "data-mapping" property is unsupported
 434  * * -ENODEV - the "data-mapping" property is missing
 435  */
 436 int drm_of_lvds_get_data_mapping(const struct device_node *port)
 437 {
 438         const char *mapping;
 439         int ret;
 440
 441         ret = of_property_read_string(port, "data-mapping", &mapping);
 442         if (ret < 0)
 443                 return -ENODEV;
 444
 445         if (!strcmp(mapping, "jeida-18"))
 446                 return MEDIA_BUS_FMT_RGB666_1X7X3_SPWG;
 447         if (!strcmp(mapping, "jeida-24"))
 448                 return MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA;
 449         if (!strcmp(mapping, "vesa-24"))
 450                 return MEDIA_BUS_FMT_RGB888_1X7X4_SPWG;
 451
 452         return -EINVAL;
 453 }
 454 EXPORT_SYMBOL_GPL(drm_of_lvds_get_data_mapping);