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); 455