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 /** 345 * drm_of_lvds_get_dual_link_pixel_order - Get LVDS dual-link pixel order 346 * @port1: First DT port node of the Dual-link LVDS source 347 * @port2: Second DT port node of the Dual-link LVDS source 348 * 349 * An LVDS dual-link connection is made of two links, with even pixels 350 * transitting on one link, and odd pixels on the other link. This function 351 * returns, for two ports of an LVDS dual-link source, which port shall transmit 352 * 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 and 355 * dual-lvds-odd-pixels properties in the sink's DT port nodes. If those 356 * properties are not present, or if their usage is not valid, this function 357 * 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 different 362 * parents when, for instance, two separate LVDS encoders carry the even and odd 363 * pixels. 364 * 365 * Return: 366 * * DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS - @port1 carries even pixels and @port2 367 * carries odd pixels 368 * * DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS - @port1 carries odd pixels and @port2 369 * carries even pixels 370 * * -EINVAL - @port1 and @port2 are not connected to a dual-link LVDS sink, or 371 * the sink configuration is invalid 372 * * -EPIPE - when @port1 or @port2 are not connected 373 */ 374 int 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 with 392 * "dual-lvds-even-pixels", and the other remote port is marked with 393 * "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 } 402 EXPORT_SYMBOL_GPL(drm_of_lvds_get_dual_link_pixel_order); 403 404 /** 405 * drm_of_lvds_get_data_mapping - Get LVDS data mapping 406 * @port: DT port node of the LVDS source or sink 407 * 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 unsupported 415 * * -ENODEV - the "data-mapping" property is missing 416 */ 417 int 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 } 435 EXPORT_SYMBOL_GPL(drm_of_lvds_get_data_mapping); 436 437 /** 438 * drm_of_get_data_lanes_count - Get DSI/(e)DP data lane count 439 * @endpoint: DT endpoint node of the DSI/(e)DP source or sink 440 * @min: minimum supported number of data lanes 441 * @max: maximum supported number of data lanes 442 * 443 * Count DT "data-lanes" property elements and check for validity. 444 * 445 * Return: 446 * * min..max - positive integer count of "data-lanes" elements 447 * * -ve - the "data-lanes" property is missing or invalid 448 * * -EINVAL - the "data-lanes" property is unsupported 449 */ 450 int 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 } 464 EXPORT_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 endpoint 468 * @port: DT port node of the DSI/(e)DP source or sink 469 * @port_reg: identifier (value of reg property) of the parent port node 470 * @reg: identifier (value of reg property) of the endpoint node 471 * @min: minimum supported number of data lanes 472 * @max: maximum supported number of data lanes 473 * 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" elements 479 * * -EINVAL - the "data-mapping" property is unsupported 480 * * -ENODEV - the "data-mapping" property is missing 481 */ 482 int 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 } 496 EXPORT_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 device 502 * @dev: parent device of display (SPI, I2C) 503 * 504 * Gets parent DSI bus for a DSI device controlled through a bus other 505 * than MIPI-DCS (SPI, I2C, etc.) using the Device Tree. 506 * 507 * Returns pointer to mipi_dsi_host if successful, -EINVAL if the 508 * request is unsupported, -EPROBE_DEFER if the DSI host is found but 509 * not available, or -ENODEV otherwise. 510 */ 511 struct 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 then 525 * 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 error 534 * or the return is null assume we're not ready to probe just 535 * 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 } 544 EXPORT_SYMBOL_GPL(drm_of_get_dsi_bus); 545 546 #endif /* CONFIG_DRM_MIPI_DSI */ 547