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/media-bus-format.h>
   6 #include <linux/of.h>
   7 #include <linux/of_graph.h>
   8
   9 #include <drm/drm_bridge.h>
  10 #include <drm/drm_crtc.h>
  11 #include <drm/drm_device.h>
  12 #include <drm/drm_encoder.h>
  13 #include <drm/drm_mipi_dsi.h>
  14 #include <drm/drm_of.h>
  15 #include <drm/drm_panel.h>
  16
  17 /**
  18  * DOC: overview
  19  *
  20  * A set of helper functions to aid DRM drivers in parsing standard DT
  21  * properties.
  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, component_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  * This function is deprecated and should not be used in new drivers. Use
 233  * devm_drm_of_get_bridge() instead.
 234  *
 235  * Returns zero if successful, or one of the standard error codes if it fails.
 236  */
 237 int drm_of_find_panel_or_bridge(const struct device_node *np,
 238                                 int port, int endpoint,
 239                                 struct drm_panel **panel,
 240                                 struct drm_bridge **bridge)
 241 {
 242         int ret = -EPROBE_DEFER;
 243         struct device_node *remote;
 244
 245         if (!panel && !bridge)
 246                 return -EINVAL;
 247         if (panel)
 248                 *panel = NULL;
 249
 250         /*
 251          * of_graph_get_remote_node() produces a noisy error message if port
 252          * node isn't found and the absence of the port is a legit case here,
 253          * so at first we silently check whether graph presents in the
 254          * device-tree node.
 255          */
 256         if (!of_graph_is_present(np))
 257                 return -ENODEV;
 258
 259         remote = of_graph_get_remote_node(np, port, endpoint);
 260         if (!remote)
 261                 return -ENODEV;
 262
 263         if (panel) {
 264                 *panel = of_drm_find_panel(remote);
 265                 if (!IS_ERR(*panel))
 266                         ret = 0;
 267                 else
 268                         *panel = NULL;
 269         }
 270
 271         /* No panel found yet, check for a bridge next. */
 272         if (bridge) {
 273                 if (ret) {
 274                         *bridge = of_drm_find_bridge(remote);
 275                         if (*bridge)
 276                                 ret = 0;
 277                 } else {
 278                         *bridge = NULL;
 279                 }
 280
 281         }
 282
 283         of_node_put(remote);
 284         return ret;
 285 }
 286 EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);
 287
 288 enum drm_of_lvds_pixels {
 289         DRM_OF_LVDS_EVEN = BIT(0),
 290         DRM_OF_LVDS_ODD = BIT(1),
 291 };
 292
 293 static int drm_of_lvds_get_port_pixels_type(struct device_node *port_node)
 294 {
 295         bool even_pixels =
 296                 of_property_read_bool(port_node, "dual-lvds-even-pixels");
 297         bool odd_pixels =
 298                 of_property_read_bool(port_node, "dual-lvds-odd-pixels");
 299
 300         return (even_pixels ? DRM_OF_LVDS_EVEN : 0) |
 301                (odd_pixels ? DRM_OF_LVDS_ODD : 0);
 302 }
 303
 304 static int drm_of_lvds_get_remote_pixels_type(
 305                         const struct device_node *port_node)
 306 {
 307         struct device_node *endpoint = NULL;
 308         int pixels_type = -EPIPE;
 309
 310         for_each_child_of_node(port_node, endpoint) {
 311                 struct device_node *remote_port;
 312                 int current_pt;
 313
 314                 if (!of_node_name_eq(endpoint, "endpoint"))
 315                         continue;
 316
 317                 remote_port = of_graph_get_remote_port(endpoint);
 318                 if (!remote_port) {
 319                         of_node_put(endpoint);
 320                         return -EPIPE;
 321                 }
 322
 323                 current_pt = drm_of_lvds_get_port_pixels_type(remote_port);
 324                 of_node_put(remote_port);
 325                 if (pixels_type < 0)
 326                         pixels_type = current_pt;
 327
 328                 /*
 329                  * Sanity check, ensure that all remote endpoints have the same
 330                  * pixel type. We may lift this restriction later if we need to
 331                  * support multiple sinks with different dual-link
 332                  * configurations by passing the endpoints explicitly to
 333                  * drm_of_lvds_get_dual_link_pixel_order().
 334                  */
 335                 if (!current_pt || pixels_type != current_pt) {
 336                         of_node_put(endpoint);
 337                         return -EINVAL;
 338                 }
 339         }
 340
 341         return pixels_type;
 342 }
 343
 344 static int __drm_of_lvds_get_dual_link_pixel_order(int p1_pt, int p2_pt)
 345 {
 346         /*
 347          * A valid dual-lVDS bus is found when one port is marked with
 348          * "dual-lvds-even-pixels", and the other port is marked with
 349          * "dual-lvds-odd-pixels", bail out if the markers are not right.
 350          */
 351         if (p1_pt + p2_pt != DRM_OF_LVDS_EVEN + DRM_OF_LVDS_ODD)
 352                 return -EINVAL;
 353
 354         return p1_pt == DRM_OF_LVDS_EVEN ?
 355                 DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS :
 356                 DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS;
 357 }
 358
 359 /**
 360  * drm_of_lvds_get_dual_link_pixel_order - Get LVDS dual-link source pixel order
 361  * @port1: First DT port node of the Dual-link LVDS source
 362  * @port2: Second DT port node of the Dual-link LVDS source
 363  *
 364  * An LVDS dual-link connection is made of two links, with even pixels
 365  * transitting on one link, and odd pixels on the other link. This function
 366  * returns, for two ports of an LVDS dual-link source, which port shall transmit
 367  * the even and odd pixels, based on the requirements of the connected sink.
 368  *
 369  * The pixel order is determined from the dual-lvds-even-pixels and
 370  * dual-lvds-odd-pixels properties in the sink's DT port nodes. If those
 371  * properties are not present, or if their usage is not valid, this function
 372  * returns -EINVAL.
 373  *
 374  * If either port is not connected, this function returns -EPIPE.
 375  *
 376  * @port1 and @port2 are typically DT sibling nodes, but may have different
 377  * parents when, for instance, two separate LVDS encoders carry the even and odd
 378  * pixels.
 379  *
 380  * Return:
 381  * * DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS - @port1 carries even pixels and @port2
 382  *   carries odd pixels
 383  * * DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS - @port1 carries odd pixels and @port2
 384  *   carries even pixels
 385  * * -EINVAL - @port1 and @port2 are not connected to a dual-link LVDS sink, or
 386  *   the sink configuration is invalid
 387  * * -EPIPE - when @port1 or @port2 are not connected
 388  */
 389 int drm_of_lvds_get_dual_link_pixel_order(const struct device_node *port1,
 390                                           const struct device_node *port2)
 391 {
 392         int remote_p1_pt, remote_p2_pt;
 393
 394         if (!port1 || !port2)
 395                 return -EINVAL;
 396
 397         remote_p1_pt = drm_of_lvds_get_remote_pixels_type(port1);
 398         if (remote_p1_pt < 0)
 399                 return remote_p1_pt;
 400
 401         remote_p2_pt = drm_of_lvds_get_remote_pixels_type(port2);
 402         if (remote_p2_pt < 0)
 403                 return remote_p2_pt;
 404
 405         return __drm_of_lvds_get_dual_link_pixel_order(remote_p1_pt, remote_p2_pt);
 406 }
 407 EXPORT_SYMBOL_GPL(drm_of_lvds_get_dual_link_pixel_order);
 408
 409 /**
 410  * drm_of_lvds_get_dual_link_pixel_order_sink - Get LVDS dual-link sink pixel order
 411  * @port1: First DT port node of the Dual-link LVDS sink
 412  * @port2: Second DT port node of the Dual-link LVDS sink
 413  *
 414  * An LVDS dual-link connection is made of two links, with even pixels
 415  * transitting on one link, and odd pixels on the other link. This function
 416  * returns, for two ports of an LVDS dual-link sink, which port shall transmit
 417  * the even and odd pixels, based on the requirements of the sink.
 418  *
 419  * The pixel order is determined from the dual-lvds-even-pixels and
 420  * dual-lvds-odd-pixels properties in the sink's DT port nodes. If those
 421  * properties are not present, or if their usage is not valid, this function
 422  * returns -EINVAL.
 423  *
 424  * If either port is not connected, this function returns -EPIPE.
 425  *
 426  * @port1 and @port2 are typically DT sibling nodes, but may have different
 427  * parents when, for instance, two separate LVDS decoders receive the even and
 428  * odd pixels.
 429  *
 430  * Return:
 431  * * DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS - @port1 receives even pixels and @port2
 432  *   receives odd pixels
 433  * * DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS - @port1 receives odd pixels and @port2
 434  *   receives even pixels
 435  * * -EINVAL - @port1 or @port2 are NULL
 436  * * -EPIPE - when @port1 or @port2 are not connected
 437  */
 438 int drm_of_lvds_get_dual_link_pixel_order_sink(struct device_node *port1,
 439                                                struct device_node *port2)
 440 {
 441         int sink_p1_pt, sink_p2_pt;
 442
 443         if (!port1 || !port2)
 444                 return -EINVAL;
 445
 446         sink_p1_pt = drm_of_lvds_get_port_pixels_type(port1);
 447         if (!sink_p1_pt)
 448                 return -EPIPE;
 449
 450         sink_p2_pt = drm_of_lvds_get_port_pixels_type(port2);
 451         if (!sink_p2_pt)
 452                 return -EPIPE;
 453
 454         return __drm_of_lvds_get_dual_link_pixel_order(sink_p1_pt, sink_p2_pt);
 455 }
 456 EXPORT_SYMBOL_GPL(drm_of_lvds_get_dual_link_pixel_order_sink);
 457
 458 /**
 459  * drm_of_lvds_get_data_mapping - Get LVDS data mapping
 460  * @port: DT port node of the LVDS source or sink
 461  *
 462  * Convert DT "data-mapping" property string value into media bus format value.
 463  *
 464  * Return:
 465  * * MEDIA_BUS_FMT_RGB666_1X7X3_SPWG - data-mapping is "jeida-18"
 466  * * MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA - data-mapping is "jeida-24"
 467  * * MEDIA_BUS_FMT_RGB101010_1X7X5_JEIDA - data-mapping is "jeida-30"
 468  * * MEDIA_BUS_FMT_RGB888_1X7X4_SPWG - data-mapping is "vesa-24"
 469  * * MEDIA_BUS_FMT_RGB101010_1X7X5_SPWG - data-mapping is "vesa-30"
 470  * * -EINVAL - the "data-mapping" property is unsupported
 471  * * -ENODEV - the "data-mapping" property is missing
 472  */
 473 int drm_of_lvds_get_data_mapping(const struct device_node *port)
 474 {
 475         const char *mapping;
 476         int ret;
 477
 478         ret = of_property_read_string(port, "data-mapping", &mapping);
 479         if (ret < 0)
 480                 return -ENODEV;
 481
 482         if (!strcmp(mapping, "jeida-18"))
 483                 return MEDIA_BUS_FMT_RGB666_1X7X3_SPWG;
 484         if (!strcmp(mapping, "jeida-24"))
 485                 return MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA;
 486         if (!strcmp(mapping, "jeida-30"))
 487                 return MEDIA_BUS_FMT_RGB101010_1X7X5_JEIDA;
 488         if (!strcmp(mapping, "vesa-24"))
 489                 return MEDIA_BUS_FMT_RGB888_1X7X4_SPWG;
 490         if (!strcmp(mapping, "vesa-30"))
 491                 return MEDIA_BUS_FMT_RGB101010_1X7X5_SPWG;
 492
 493         return -EINVAL;
 494 }
 495 EXPORT_SYMBOL_GPL(drm_of_lvds_get_data_mapping);
 496
 497 /**
 498  * drm_of_get_data_lanes_count - Get DSI/(e)DP data lane count
 499  * @endpoint: DT endpoint node of the DSI/(e)DP source or sink
 500  * @min: minimum supported number of data lanes
 501  * @max: maximum supported number of data lanes
 502  *
 503  * Count DT "data-lanes" property elements and check for validity.
 504  *
 505  * Return:
 506  * * min..max - positive integer count of "data-lanes" elements
 507  * * -ve - the "data-lanes" property is missing or invalid
 508  * * -EINVAL - the "data-lanes" property is unsupported
 509  */
 510 int drm_of_get_data_lanes_count(const struct device_node *endpoint,
 511                                 const unsigned int min, const unsigned int max)
 512 {
 513         int ret;
 514
 515         ret = of_property_count_u32_elems(endpoint, "data-lanes");
 516         if (ret < 0)
 517                 return ret;
 518
 519         if (ret < min || ret > max)
 520                 return -EINVAL;
 521
 522         return ret;
 523 }
 524 EXPORT_SYMBOL_GPL(drm_of_get_data_lanes_count);
 525
 526 /**
 527  * drm_of_get_data_lanes_count_ep - Get DSI/(e)DP data lane count by endpoint
 528  * @port: DT port node of the DSI/(e)DP source or sink
 529  * @port_reg: identifier (value of reg property) of the parent port node
 530  * @reg: identifier (value of reg property) of the endpoint node
 531  * @min: minimum supported number of data lanes
 532  * @max: maximum supported number of data lanes
 533  *
 534  * Count DT "data-lanes" property elements and check for validity.
 535  * This variant uses endpoint specifier.
 536  *
 537  * Return:
 538  * * min..max - positive integer count of "data-lanes" elements
 539  * * -EINVAL - the "data-mapping" property is unsupported
 540  * * -ENODEV - the "data-mapping" property is missing
 541  */
 542 int drm_of_get_data_lanes_count_ep(const struct device_node *port,
 543                                    int port_reg, int reg,
 544                                    const unsigned int min,
 545                                    const unsigned int max)
 546 {
 547         struct device_node *endpoint;
 548         int ret;
 549
 550         endpoint = of_graph_get_endpoint_by_regs(port, port_reg, reg);
 551         ret = drm_of_get_data_lanes_count(endpoint, min, max);
 552         of_node_put(endpoint);
 553
 554         return ret;
 555 }
 556 EXPORT_SYMBOL_GPL(drm_of_get_data_lanes_count_ep);
 557
 558 #if IS_ENABLED(CONFIG_DRM_MIPI_DSI)
 559
 560 /**
 561  * drm_of_get_dsi_bus - find the DSI bus for a given device
 562  * @dev: parent device of display (SPI, I2C)
 563  *
 564  * Gets parent DSI bus for a DSI device controlled through a bus other
 565  * than MIPI-DCS (SPI, I2C, etc.) using the Device Tree.
 566  *
 567  * This function assumes that the device's port@0 is the DSI input.
 568  *
 569  * Returns pointer to mipi_dsi_host if successful, -EINVAL if the
 570  * request is unsupported, -EPROBE_DEFER if the DSI host is found but
 571  * not available, or -ENODEV otherwise.
 572  */
 573 struct mipi_dsi_host *drm_of_get_dsi_bus(struct device *dev)
 574 {
 575         struct mipi_dsi_host *dsi_host;
 576         struct device_node *endpoint, *dsi_host_node;
 577
 578         /*
 579          * Get first endpoint child from device.
 580          */
 581         endpoint = of_graph_get_endpoint_by_regs(dev->of_node, 0, -1);
 582         if (!endpoint)
 583                 return ERR_PTR(-ENODEV);
 584
 585         /*
 586          * Follow the first endpoint to get the DSI host node and then
 587          * release the endpoint since we no longer need it.
 588          */
 589         dsi_host_node = of_graph_get_remote_port_parent(endpoint);
 590         of_node_put(endpoint);
 591         if (!dsi_host_node)
 592                 return ERR_PTR(-ENODEV);
 593
 594         /*
 595          * Get the DSI host from the DSI host node. If we get an error
 596          * or the return is null assume we're not ready to probe just
 597          * yet. Release the DSI host node since we're done with it.
 598          */
 599         dsi_host = of_find_mipi_dsi_host_by_node(dsi_host_node);
 600         of_node_put(dsi_host_node);
 601         if (IS_ERR_OR_NULL(dsi_host))
 602                 return ERR_PTR(-EPROBE_DEFER);
 603
 604         return dsi_host;
 605 }
 606 EXPORT_SYMBOL_GPL(drm_of_get_dsi_bus);
 607
 608 #endif /* CONFIG_DRM_MIPI_DSI */