547 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2#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: overview19 *20 * A set of helper functions to aid DRM drivers in parsing standard DT21 * properties.22 */23 24/**25 * drm_of_crtc_port_mask - find the mask of a registered CRTC by port OF node26 * @dev: DRM device27 * @port: port OF node28 *29 * Given a port OF node, return the possible mask of the corresponding30 * CRTC within a device's list of CRTCs. Returns zero if not found.31 */32uint32_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}47EXPORT_SYMBOL(drm_of_crtc_port_mask);48 49/**50 * drm_of_find_possible_crtcs - find the possible CRTCs for an encoder port51 * @dev: DRM device52 * @port: encoder port to scan for endpoints53 *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 this56 * encoder.57 *58 * See Documentation/devicetree/bindings/graph.txt for the bindings.59 */60uint32_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}80EXPORT_SYMBOL(drm_of_find_possible_crtcs);81 82/**83 * drm_of_component_match_add - Add a component helper OF node match rule84 * @master: master device85 * @matchptr: component match pointer86 * @compare: compare function used for matching component87 * @node: of_node88 */89void 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}98EXPORT_SYMBOL_GPL(drm_of_component_match_add);99 100/**101 * drm_of_component_probe - Generic probe function for a component based master102 * @dev: master device containing the OF node103 * @compare_of: compare function used for matching components104 * @m_ops: component master ops to be used105 *106 * Parse the platform device OF node and bind all the components associated107 * with the master. Interface ports are added before the encoders in order to108 * satisfy their .bind requirements109 * 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 */113int 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 expected127 */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 endpoint152 */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}184EXPORT_SYMBOL(drm_of_component_probe);185 186/*187 * drm_of_encoder_active_endpoint - return the active encoder endpoint188 * @node: device tree node containing encoder input ports189 * @encoder: drm_encoder190 *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 */194int 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}218EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);219 220/**221 * drm_of_find_panel_or_bridge - return connected panel or bridge device222 * @np: device tree node containing encoder output ports223 * @port: port in the device tree node224 * @endpoint: endpoint in the device tree node225 * @panel: pointer to hold returned drm_panel226 * @bridge: pointer to hold returned drm_bridge227 *228 * Given a DT node's port and endpoint number, find the connected node and229 * return either the associated struct drm_panel or drm_bridge device. Either230 * @panel or @bridge must not be NULL.231 *232 * This function is deprecated and should not be used in new drivers. Use233 * devm_drm_of_get_bridge() instead.234 *235 * Returns zero if successful, or one of the standard error codes if it fails.236 */237int 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 port252 * 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 the254 * 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 else268 *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}286EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);287 288enum drm_of_lvds_pixels {289 DRM_OF_LVDS_EVEN = BIT(0),290 DRM_OF_LVDS_ODD = BIT(1),291};292 293static 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 304static 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 same330 * pixel type. We may lift this restriction later if we need to331 * support multiple sinks with different dual-link332 * configurations by passing the endpoints explicitly to333 * 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/**345 * drm_of_lvds_get_dual_link_pixel_order - Get LVDS dual-link pixel order346 * @port1: First DT port node of the Dual-link LVDS source347 * @port2: Second DT port node of the Dual-link LVDS source348 *349 * An LVDS dual-link connection is made of two links, with even pixels350 * transitting on one link, and odd pixels on the other link. This function351 * returns, for two ports of an LVDS dual-link source, which port shall transmit352 * the even and odd pixels, based on the requirements of the connected sink.353 *354 * The pixel order is determined from the dual-lvds-even-pixels and355 * dual-lvds-odd-pixels properties in the sink's DT port nodes. If those356 * properties are not present, or if their usage is not valid, this function357 * returns -EINVAL.358 *359 * If either port is not connected, this function returns -EPIPE.360 *361 * @port1 and @port2 are typically DT sibling nodes, but may have different362 * parents when, for instance, two separate LVDS encoders carry the even and odd363 * pixels.364 *365 * Return:366 * * DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS - @port1 carries even pixels and @port2367 * carries odd pixels368 * * DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS - @port1 carries odd pixels and @port2369 * carries even pixels370 * * -EINVAL - @port1 and @port2 are not connected to a dual-link LVDS sink, or371 * the sink configuration is invalid372 * * -EPIPE - when @port1 or @port2 are not connected373 */374int drm_of_lvds_get_dual_link_pixel_order(const struct device_node *port1,375 const struct device_node *port2)376{377 int remote_p1_pt, remote_p2_pt;378 379 if (!port1 || !port2)380 return -EINVAL;381 382 remote_p1_pt = drm_of_lvds_get_remote_pixels_type(port1);383 if (remote_p1_pt < 0)384 return remote_p1_pt;385 386 remote_p2_pt = drm_of_lvds_get_remote_pixels_type(port2);387 if (remote_p2_pt < 0)388 return remote_p2_pt;389 390 /*391 * A valid dual-lVDS bus is found when one remote port is marked with392 * "dual-lvds-even-pixels", and the other remote port is marked with393 * "dual-lvds-odd-pixels", bail out if the markers are not right.394 */395 if (remote_p1_pt + remote_p2_pt != DRM_OF_LVDS_EVEN + DRM_OF_LVDS_ODD)396 return -EINVAL;397 398 return remote_p1_pt == DRM_OF_LVDS_EVEN ?399 DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS :400 DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS;401}402EXPORT_SYMBOL_GPL(drm_of_lvds_get_dual_link_pixel_order);403 404/**405 * drm_of_lvds_get_data_mapping - Get LVDS data mapping406 * @port: DT port node of the LVDS source or sink407 *408 * Convert DT "data-mapping" property string value into media bus format value.409 *410 * Return:411 * * MEDIA_BUS_FMT_RGB666_1X7X3_SPWG - data-mapping is "jeida-18"412 * * MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA - data-mapping is "jeida-24"413 * * MEDIA_BUS_FMT_RGB888_1X7X4_SPWG - data-mapping is "vesa-24"414 * * -EINVAL - the "data-mapping" property is unsupported415 * * -ENODEV - the "data-mapping" property is missing416 */417int drm_of_lvds_get_data_mapping(const struct device_node *port)418{419 const char *mapping;420 int ret;421 422 ret = of_property_read_string(port, "data-mapping", &mapping);423 if (ret < 0)424 return -ENODEV;425 426 if (!strcmp(mapping, "jeida-18"))427 return MEDIA_BUS_FMT_RGB666_1X7X3_SPWG;428 if (!strcmp(mapping, "jeida-24"))429 return MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA;430 if (!strcmp(mapping, "vesa-24"))431 return MEDIA_BUS_FMT_RGB888_1X7X4_SPWG;432 433 return -EINVAL;434}435EXPORT_SYMBOL_GPL(drm_of_lvds_get_data_mapping);436 437/**438 * drm_of_get_data_lanes_count - Get DSI/(e)DP data lane count439 * @endpoint: DT endpoint node of the DSI/(e)DP source or sink440 * @min: minimum supported number of data lanes441 * @max: maximum supported number of data lanes442 *443 * Count DT "data-lanes" property elements and check for validity.444 *445 * Return:446 * * min..max - positive integer count of "data-lanes" elements447 * * -ve - the "data-lanes" property is missing or invalid448 * * -EINVAL - the "data-lanes" property is unsupported449 */450int drm_of_get_data_lanes_count(const struct device_node *endpoint,451 const unsigned int min, const unsigned int max)452{453 int ret;454 455 ret = of_property_count_u32_elems(endpoint, "data-lanes");456 if (ret < 0)457 return ret;458 459 if (ret < min || ret > max)460 return -EINVAL;461 462 return ret;463}464EXPORT_SYMBOL_GPL(drm_of_get_data_lanes_count);465 466/**467 * drm_of_get_data_lanes_count_ep - Get DSI/(e)DP data lane count by endpoint468 * @port: DT port node of the DSI/(e)DP source or sink469 * @port_reg: identifier (value of reg property) of the parent port node470 * @reg: identifier (value of reg property) of the endpoint node471 * @min: minimum supported number of data lanes472 * @max: maximum supported number of data lanes473 *474 * Count DT "data-lanes" property elements and check for validity.475 * This variant uses endpoint specifier.476 *477 * Return:478 * * min..max - positive integer count of "data-lanes" elements479 * * -EINVAL - the "data-mapping" property is unsupported480 * * -ENODEV - the "data-mapping" property is missing481 */482int drm_of_get_data_lanes_count_ep(const struct device_node *port,483 int port_reg, int reg,484 const unsigned int min,485 const unsigned int max)486{487 struct device_node *endpoint;488 int ret;489 490 endpoint = of_graph_get_endpoint_by_regs(port, port_reg, reg);491 ret = drm_of_get_data_lanes_count(endpoint, min, max);492 of_node_put(endpoint);493 494 return ret;495}496EXPORT_SYMBOL_GPL(drm_of_get_data_lanes_count_ep);497 498#if IS_ENABLED(CONFIG_DRM_MIPI_DSI)499 500/**501 * drm_of_get_dsi_bus - find the DSI bus for a given device502 * @dev: parent device of display (SPI, I2C)503 *504 * Gets parent DSI bus for a DSI device controlled through a bus other505 * than MIPI-DCS (SPI, I2C, etc.) using the Device Tree.506 *507 * Returns pointer to mipi_dsi_host if successful, -EINVAL if the508 * request is unsupported, -EPROBE_DEFER if the DSI host is found but509 * not available, or -ENODEV otherwise.510 */511struct mipi_dsi_host *drm_of_get_dsi_bus(struct device *dev)512{513 struct mipi_dsi_host *dsi_host;514 struct device_node *endpoint, *dsi_host_node;515 516 /*517 * Get first endpoint child from device.518 */519 endpoint = of_graph_get_next_endpoint(dev->of_node, NULL);520 if (!endpoint)521 return ERR_PTR(-ENODEV);522 523 /*524 * Follow the first endpoint to get the DSI host node and then525 * release the endpoint since we no longer need it.526 */527 dsi_host_node = of_graph_get_remote_port_parent(endpoint);528 of_node_put(endpoint);529 if (!dsi_host_node)530 return ERR_PTR(-ENODEV);531 532 /*533 * Get the DSI host from the DSI host node. If we get an error534 * or the return is null assume we're not ready to probe just535 * yet. Release the DSI host node since we're done with it.536 */537 dsi_host = of_find_mipi_dsi_host_by_node(dsi_host_node);538 of_node_put(dsi_host_node);539 if (IS_ERR_OR_NULL(dsi_host))540 return ERR_PTR(-EPROBE_DEFER);541 542 return dsi_host;543}544EXPORT_SYMBOL_GPL(drm_of_get_dsi_bus);545 546#endif /* CONFIG_DRM_MIPI_DSI */547