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