1 /* 2 * Copyright (c) 2014 Samsung Electronics Co., Ltd 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sub license, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the 12 * next paragraph) shall be included in all copies or substantial portions 13 * of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 #include <linux/err.h> 25 #include <linux/media-bus-format.h> 26 #include <linux/module.h> 27 #include <linux/mutex.h> 28 29 #include <drm/drm_atomic_state_helper.h> 30 #include <drm/drm_bridge.h> 31 #include <drm/drm_debugfs.h> 32 #include <drm/drm_edid.h> 33 #include <drm/drm_encoder.h> 34 #include <drm/drm_file.h> 35 #include <drm/drm_of.h> 36 #include <drm/drm_print.h> 37 38 #include "drm_crtc_internal.h" 39 40 /** 41 * DOC: overview 42 * 43 * &struct drm_bridge represents a device that hangs on to an encoder. These are 44 * handy when a regular &drm_encoder entity isn't enough to represent the entire 45 * encoder chain. 46 * 47 * A bridge is always attached to a single &drm_encoder at a time, but can be 48 * either connected to it directly, or through a chain of bridges:: 49 * 50 * [ CRTC ---> ] Encoder ---> Bridge A ---> Bridge B 51 * 52 * Here, the output of the encoder feeds to bridge A, and that furthers feeds to 53 * bridge B. Bridge chains can be arbitrarily long, and shall be fully linear: 54 * Chaining multiple bridges to the output of a bridge, or the same bridge to 55 * the output of different bridges, is not supported. 56 * 57 * &drm_bridge, like &drm_panel, aren't &drm_mode_object entities like planes, 58 * CRTCs, encoders or connectors and hence are not visible to userspace. They 59 * just provide additional hooks to get the desired output at the end of the 60 * encoder chain. 61 */ 62 63 /** 64 * DOC: display driver integration 65 * 66 * Display drivers are responsible for linking encoders with the first bridge 67 * in the chains. This is done by acquiring the appropriate bridge with 68 * devm_drm_of_get_bridge(). Once acquired, the bridge shall be attached to the 69 * encoder with a call to drm_bridge_attach(). 70 * 71 * Bridges are responsible for linking themselves with the next bridge in the 72 * chain, if any. This is done the same way as for encoders, with the call to 73 * drm_bridge_attach() occurring in the &drm_bridge_funcs.attach operation. 74 * 75 * Once these links are created, the bridges can participate along with encoder 76 * functions to perform mode validation and fixup (through 77 * drm_bridge_chain_mode_valid() and drm_atomic_bridge_chain_check()), mode 78 * setting (through drm_bridge_chain_mode_set()), enable (through 79 * drm_atomic_bridge_chain_pre_enable() and drm_atomic_bridge_chain_enable()) 80 * and disable (through drm_atomic_bridge_chain_disable() and 81 * drm_atomic_bridge_chain_post_disable()). Those functions call the 82 * corresponding operations provided in &drm_bridge_funcs in sequence for all 83 * bridges in the chain. 84 * 85 * For display drivers that use the atomic helpers 86 * drm_atomic_helper_check_modeset(), 87 * drm_atomic_helper_commit_modeset_enables() and 88 * drm_atomic_helper_commit_modeset_disables() (either directly in hand-rolled 89 * commit check and commit tail handlers, or through the higher-level 90 * drm_atomic_helper_check() and drm_atomic_helper_commit_tail() or 91 * drm_atomic_helper_commit_tail_rpm() helpers), this is done transparently and 92 * requires no intervention from the driver. For other drivers, the relevant 93 * DRM bridge chain functions shall be called manually. 94 * 95 * Bridges also participate in implementing the &drm_connector at the end of 96 * the bridge chain. Display drivers may use the drm_bridge_connector_init() 97 * helper to create the &drm_connector, or implement it manually on top of the 98 * connector-related operations exposed by the bridge (see the overview 99 * documentation of bridge operations for more details). 100 */ 101 102 /** 103 * DOC: special care dsi 104 * 105 * The interaction between the bridges and other frameworks involved in 106 * the probing of the upstream driver and the bridge driver can be 107 * challenging. Indeed, there's multiple cases that needs to be 108 * considered: 109 * 110 * - The upstream driver doesn't use the component framework and isn't a 111 * MIPI-DSI host. In this case, the bridge driver will probe at some 112 * point and the upstream driver should try to probe again by returning 113 * EPROBE_DEFER as long as the bridge driver hasn't probed. 114 * 115 * - The upstream driver doesn't use the component framework, but is a 116 * MIPI-DSI host. The bridge device uses the MIPI-DCS commands to be 117 * controlled. In this case, the bridge device is a child of the 118 * display device and when it will probe it's assured that the display 119 * device (and MIPI-DSI host) is present. The upstream driver will be 120 * assured that the bridge driver is connected between the 121 * &mipi_dsi_host_ops.attach and &mipi_dsi_host_ops.detach operations. 122 * Therefore, it must run mipi_dsi_host_register() in its probe 123 * function, and then run drm_bridge_attach() in its 124 * &mipi_dsi_host_ops.attach hook. 125 * 126 * - The upstream driver uses the component framework and is a MIPI-DSI 127 * host. The bridge device uses the MIPI-DCS commands to be 128 * controlled. This is the same situation than above, and can run 129 * mipi_dsi_host_register() in either its probe or bind hooks. 130 * 131 * - The upstream driver uses the component framework and is a MIPI-DSI 132 * host. The bridge device uses a separate bus (such as I2C) to be 133 * controlled. In this case, there's no correlation between the probe 134 * of the bridge and upstream drivers, so care must be taken to avoid 135 * an endless EPROBE_DEFER loop, with each driver waiting for the 136 * other to probe. 137 * 138 * The ideal pattern to cover the last item (and all the others in the 139 * MIPI-DSI host driver case) is to split the operations like this: 140 * 141 * - The MIPI-DSI host driver must run mipi_dsi_host_register() in its 142 * probe hook. It will make sure that the MIPI-DSI host sticks around, 143 * and that the driver's bind can be called. 144 * 145 * - In its probe hook, the bridge driver must try to find its MIPI-DSI 146 * host, register as a MIPI-DSI device and attach the MIPI-DSI device 147 * to its host. The bridge driver is now functional. 148 * 149 * - In its &struct mipi_dsi_host_ops.attach hook, the MIPI-DSI host can 150 * now add its component. Its bind hook will now be called and since 151 * the bridge driver is attached and registered, we can now look for 152 * and attach it. 153 * 154 * At this point, we're now certain that both the upstream driver and 155 * the bridge driver are functional and we can't have a deadlock-like 156 * situation when probing. 157 */ 158 159 /** 160 * DOC: dsi bridge operations 161 * 162 * DSI host interfaces are expected to be implemented as bridges rather than 163 * encoders, however there are a few aspects of their operation that need to 164 * be defined in order to provide a consistent interface. 165 * 166 * A DSI host should keep the PHY powered down until the pre_enable operation is 167 * called. All lanes are in an undefined idle state up to this point, and it 168 * must not be assumed that it is LP-11. 169 * pre_enable should initialise the PHY, set the data lanes to LP-11, and the 170 * clock lane to either LP-11 or HS depending on the mode_flag 171 * %MIPI_DSI_CLOCK_NON_CONTINUOUS. 172 * 173 * Ordinarily the downstream bridge DSI peripheral pre_enable will have been 174 * called before the DSI host. If the DSI peripheral requires LP-11 and/or 175 * the clock lane to be in HS mode prior to pre_enable, then it can set the 176 * &pre_enable_prev_first flag to request the pre_enable (and 177 * post_disable) order to be altered to enable the DSI host first. 178 * 179 * Either the CRTC being enabled, or the DSI host enable operation should switch 180 * the host to actively transmitting video on the data lanes. 181 * 182 * The reverse also applies. The DSI host disable operation or stopping the CRTC 183 * should stop transmitting video, and the data lanes should return to the LP-11 184 * state. The DSI host &post_disable operation should disable the PHY. 185 * If the &pre_enable_prev_first flag is set, then the DSI peripheral's 186 * bridge &post_disable will be called before the DSI host's post_disable. 187 * 188 * Whilst it is valid to call &host_transfer prior to pre_enable or after 189 * post_disable, the exact state of the lanes is undefined at this point. The 190 * DSI host should initialise the interface, transmit the data, and then disable 191 * the interface again. 192 * 193 * Ultra Low Power State (ULPS) is not explicitly supported by DRM. If 194 * implemented, it therefore needs to be handled entirely within the DSI Host 195 * driver. 196 */ 197 198 static DEFINE_MUTEX(bridge_lock); 199 static LIST_HEAD(bridge_list); 200 201 /** 202 * drm_bridge_add - add the given bridge to the global bridge list 203 * 204 * @bridge: bridge control structure 205 */ 206 void drm_bridge_add(struct drm_bridge *bridge) 207 { 208 mutex_init(&bridge->hpd_mutex); 209 210 mutex_lock(&bridge_lock); 211 list_add_tail(&bridge->list, &bridge_list); 212 mutex_unlock(&bridge_lock); 213 } 214 EXPORT_SYMBOL(drm_bridge_add); 215 216 static void drm_bridge_remove_void(void *bridge) 217 { 218 drm_bridge_remove(bridge); 219 } 220 221 /** 222 * devm_drm_bridge_add - devm managed version of drm_bridge_add() 223 * 224 * @dev: device to tie the bridge lifetime to 225 * @bridge: bridge control structure 226 * 227 * This is the managed version of drm_bridge_add() which automatically 228 * calls drm_bridge_remove() when @dev is unbound. 229 * 230 * Return: 0 if no error or negative error code. 231 */ 232 int devm_drm_bridge_add(struct device *dev, struct drm_bridge *bridge) 233 { 234 drm_bridge_add(bridge); 235 return devm_add_action_or_reset(dev, drm_bridge_remove_void, bridge); 236 } 237 EXPORT_SYMBOL(devm_drm_bridge_add); 238 239 /** 240 * drm_bridge_remove - remove the given bridge from the global bridge list 241 * 242 * @bridge: bridge control structure 243 */ 244 void drm_bridge_remove(struct drm_bridge *bridge) 245 { 246 mutex_lock(&bridge_lock); 247 list_del_init(&bridge->list); 248 mutex_unlock(&bridge_lock); 249 250 mutex_destroy(&bridge->hpd_mutex); 251 } 252 EXPORT_SYMBOL(drm_bridge_remove); 253 254 static struct drm_private_state * 255 drm_bridge_atomic_duplicate_priv_state(struct drm_private_obj *obj) 256 { 257 struct drm_bridge *bridge = drm_priv_to_bridge(obj); 258 struct drm_bridge_state *state; 259 260 state = bridge->funcs->atomic_duplicate_state(bridge); 261 return state ? &state->base : NULL; 262 } 263 264 static void 265 drm_bridge_atomic_destroy_priv_state(struct drm_private_obj *obj, 266 struct drm_private_state *s) 267 { 268 struct drm_bridge_state *state = drm_priv_to_bridge_state(s); 269 struct drm_bridge *bridge = drm_priv_to_bridge(obj); 270 271 bridge->funcs->atomic_destroy_state(bridge, state); 272 } 273 274 static const struct drm_private_state_funcs drm_bridge_priv_state_funcs = { 275 .atomic_duplicate_state = drm_bridge_atomic_duplicate_priv_state, 276 .atomic_destroy_state = drm_bridge_atomic_destroy_priv_state, 277 }; 278 279 /** 280 * drm_bridge_attach - attach the bridge to an encoder's chain 281 * 282 * @encoder: DRM encoder 283 * @bridge: bridge to attach 284 * @previous: previous bridge in the chain (optional) 285 * @flags: DRM_BRIDGE_ATTACH_* flags 286 * 287 * Called by a kms driver to link the bridge to an encoder's chain. The previous 288 * argument specifies the previous bridge in the chain. If NULL, the bridge is 289 * linked directly at the encoder's output. Otherwise it is linked at the 290 * previous bridge's output. 291 * 292 * If non-NULL the previous bridge must be already attached by a call to this 293 * function. 294 * 295 * Note that bridges attached to encoders are auto-detached during encoder 296 * cleanup in drm_encoder_cleanup(), so drm_bridge_attach() should generally 297 * *not* be balanced with a drm_bridge_detach() in driver code. 298 * 299 * RETURNS: 300 * Zero on success, error code on failure 301 */ 302 int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, 303 struct drm_bridge *previous, 304 enum drm_bridge_attach_flags flags) 305 { 306 int ret; 307 308 if (!encoder || !bridge) 309 return -EINVAL; 310 311 if (previous && (!previous->dev || previous->encoder != encoder)) 312 return -EINVAL; 313 314 if (bridge->dev) 315 return -EBUSY; 316 317 bridge->dev = encoder->dev; 318 bridge->encoder = encoder; 319 320 if (previous) 321 list_add(&bridge->chain_node, &previous->chain_node); 322 else 323 list_add(&bridge->chain_node, &encoder->bridge_chain); 324 325 if (bridge->funcs->attach) { 326 ret = bridge->funcs->attach(bridge, flags); 327 if (ret < 0) 328 goto err_reset_bridge; 329 } 330 331 if (bridge->funcs->atomic_reset) { 332 struct drm_bridge_state *state; 333 334 state = bridge->funcs->atomic_reset(bridge); 335 if (IS_ERR(state)) { 336 ret = PTR_ERR(state); 337 goto err_detach_bridge; 338 } 339 340 drm_atomic_private_obj_init(bridge->dev, &bridge->base, 341 &state->base, 342 &drm_bridge_priv_state_funcs); 343 } 344 345 return 0; 346 347 err_detach_bridge: 348 if (bridge->funcs->detach) 349 bridge->funcs->detach(bridge); 350 351 err_reset_bridge: 352 bridge->dev = NULL; 353 bridge->encoder = NULL; 354 list_del(&bridge->chain_node); 355 356 DRM_ERROR("failed to attach bridge %pOF to encoder %s: %d\n", 357 bridge->of_node, encoder->name, ret); 358 359 return ret; 360 } 361 EXPORT_SYMBOL(drm_bridge_attach); 362 363 void drm_bridge_detach(struct drm_bridge *bridge) 364 { 365 if (WARN_ON(!bridge)) 366 return; 367 368 if (WARN_ON(!bridge->dev)) 369 return; 370 371 if (bridge->funcs->atomic_reset) 372 drm_atomic_private_obj_fini(&bridge->base); 373 374 if (bridge->funcs->detach) 375 bridge->funcs->detach(bridge); 376 377 list_del(&bridge->chain_node); 378 bridge->dev = NULL; 379 } 380 381 /** 382 * DOC: bridge operations 383 * 384 * Bridge drivers expose operations through the &drm_bridge_funcs structure. 385 * The DRM internals (atomic and CRTC helpers) use the helpers defined in 386 * drm_bridge.c to call bridge operations. Those operations are divided in 387 * three big categories to support different parts of the bridge usage. 388 * 389 * - The encoder-related operations support control of the bridges in the 390 * chain, and are roughly counterparts to the &drm_encoder_helper_funcs 391 * operations. They are used by the legacy CRTC and the atomic modeset 392 * helpers to perform mode validation, fixup and setting, and enable and 393 * disable the bridge automatically. 394 * 395 * The enable and disable operations are split in 396 * &drm_bridge_funcs.pre_enable, &drm_bridge_funcs.enable, 397 * &drm_bridge_funcs.disable and &drm_bridge_funcs.post_disable to provide 398 * finer-grained control. 399 * 400 * Bridge drivers may implement the legacy version of those operations, or 401 * the atomic version (prefixed with atomic\_), in which case they shall also 402 * implement the atomic state bookkeeping operations 403 * (&drm_bridge_funcs.atomic_duplicate_state, 404 * &drm_bridge_funcs.atomic_destroy_state and &drm_bridge_funcs.reset). 405 * Mixing atomic and non-atomic versions of the operations is not supported. 406 * 407 * - The bus format negotiation operations 408 * &drm_bridge_funcs.atomic_get_output_bus_fmts and 409 * &drm_bridge_funcs.atomic_get_input_bus_fmts allow bridge drivers to 410 * negotiate the formats transmitted between bridges in the chain when 411 * multiple formats are supported. Negotiation for formats is performed 412 * transparently for display drivers by the atomic modeset helpers. Only 413 * atomic versions of those operations exist, bridge drivers that need to 414 * implement them shall thus also implement the atomic version of the 415 * encoder-related operations. This feature is not supported by the legacy 416 * CRTC helpers. 417 * 418 * - The connector-related operations support implementing a &drm_connector 419 * based on a chain of bridges. DRM bridges traditionally create a 420 * &drm_connector for bridges meant to be used at the end of the chain. This 421 * puts additional burden on bridge drivers, especially for bridges that may 422 * be used in the middle of a chain or at the end of it. Furthermore, it 423 * requires all operations of the &drm_connector to be handled by a single 424 * bridge, which doesn't always match the hardware architecture. 425 * 426 * To simplify bridge drivers and make the connector implementation more 427 * flexible, a new model allows bridges to unconditionally skip creation of 428 * &drm_connector and instead expose &drm_bridge_funcs operations to support 429 * an externally-implemented &drm_connector. Those operations are 430 * &drm_bridge_funcs.detect, &drm_bridge_funcs.get_modes, 431 * &drm_bridge_funcs.get_edid, &drm_bridge_funcs.hpd_notify, 432 * &drm_bridge_funcs.hpd_enable and &drm_bridge_funcs.hpd_disable. When 433 * implemented, display drivers shall create a &drm_connector instance for 434 * each chain of bridges, and implement those connector instances based on 435 * the bridge connector operations. 436 * 437 * Bridge drivers shall implement the connector-related operations for all 438 * the features that the bridge hardware support. For instance, if a bridge 439 * supports reading EDID, the &drm_bridge_funcs.get_edid shall be 440 * implemented. This however doesn't mean that the DDC lines are wired to the 441 * bridge on a particular platform, as they could also be connected to an I2C 442 * controller of the SoC. Support for the connector-related operations on the 443 * running platform is reported through the &drm_bridge.ops flags. Bridge 444 * drivers shall detect which operations they can support on the platform 445 * (usually this information is provided by ACPI or DT), and set the 446 * &drm_bridge.ops flags for all supported operations. A flag shall only be 447 * set if the corresponding &drm_bridge_funcs operation is implemented, but 448 * an implemented operation doesn't necessarily imply that the corresponding 449 * flag will be set. Display drivers shall use the &drm_bridge.ops flags to 450 * decide which bridge to delegate a connector operation to. This mechanism 451 * allows providing a single static const &drm_bridge_funcs instance in 452 * bridge drivers, improving security by storing function pointers in 453 * read-only memory. 454 * 455 * In order to ease transition, bridge drivers may support both the old and 456 * new models by making connector creation optional and implementing the 457 * connected-related bridge operations. Connector creation is then controlled 458 * by the flags argument to the drm_bridge_attach() function. Display drivers 459 * that support the new model and create connectors themselves shall set the 460 * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag, and bridge drivers shall then skip 461 * connector creation. For intermediate bridges in the chain, the flag shall 462 * be passed to the drm_bridge_attach() call for the downstream bridge. 463 * Bridge drivers that implement the new model only shall return an error 464 * from their &drm_bridge_funcs.attach handler when the 465 * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag is not set. New display drivers 466 * should use the new model, and convert the bridge drivers they use if 467 * needed, in order to gradually transition to the new model. 468 */ 469 470 /** 471 * drm_bridge_chain_mode_valid - validate the mode against all bridges in the 472 * encoder chain. 473 * @bridge: bridge control structure 474 * @info: display info against which the mode shall be validated 475 * @mode: desired mode to be validated 476 * 477 * Calls &drm_bridge_funcs.mode_valid for all the bridges in the encoder 478 * chain, starting from the first bridge to the last. If at least one bridge 479 * does not accept the mode the function returns the error code. 480 * 481 * Note: the bridge passed should be the one closest to the encoder. 482 * 483 * RETURNS: 484 * MODE_OK on success, drm_mode_status Enum error code on failure 485 */ 486 enum drm_mode_status 487 drm_bridge_chain_mode_valid(struct drm_bridge *bridge, 488 const struct drm_display_info *info, 489 const struct drm_display_mode *mode) 490 { 491 struct drm_encoder *encoder; 492 493 if (!bridge) 494 return MODE_OK; 495 496 encoder = bridge->encoder; 497 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { 498 enum drm_mode_status ret; 499 500 if (!bridge->funcs->mode_valid) 501 continue; 502 503 ret = bridge->funcs->mode_valid(bridge, info, mode); 504 if (ret != MODE_OK) 505 return ret; 506 } 507 508 return MODE_OK; 509 } 510 EXPORT_SYMBOL(drm_bridge_chain_mode_valid); 511 512 /** 513 * drm_bridge_chain_mode_set - set proposed mode for all bridges in the 514 * encoder chain 515 * @bridge: bridge control structure 516 * @mode: desired mode to be set for the encoder chain 517 * @adjusted_mode: updated mode that works for this encoder chain 518 * 519 * Calls &drm_bridge_funcs.mode_set op for all the bridges in the 520 * encoder chain, starting from the first bridge to the last. 521 * 522 * Note: the bridge passed should be the one closest to the encoder 523 */ 524 void drm_bridge_chain_mode_set(struct drm_bridge *bridge, 525 const struct drm_display_mode *mode, 526 const struct drm_display_mode *adjusted_mode) 527 { 528 struct drm_encoder *encoder; 529 530 if (!bridge) 531 return; 532 533 encoder = bridge->encoder; 534 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { 535 if (bridge->funcs->mode_set) 536 bridge->funcs->mode_set(bridge, mode, adjusted_mode); 537 } 538 } 539 EXPORT_SYMBOL(drm_bridge_chain_mode_set); 540 541 /** 542 * drm_atomic_bridge_chain_disable - disables all bridges in the encoder chain 543 * @bridge: bridge control structure 544 * @old_state: old atomic state 545 * 546 * Calls &drm_bridge_funcs.atomic_disable (falls back on 547 * &drm_bridge_funcs.disable) op for all the bridges in the encoder chain, 548 * starting from the last bridge to the first. These are called before calling 549 * &drm_encoder_helper_funcs.atomic_disable 550 * 551 * Note: the bridge passed should be the one closest to the encoder 552 */ 553 void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge, 554 struct drm_atomic_state *old_state) 555 { 556 struct drm_encoder *encoder; 557 struct drm_bridge *iter; 558 559 if (!bridge) 560 return; 561 562 encoder = bridge->encoder; 563 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { 564 if (iter->funcs->atomic_disable) { 565 struct drm_bridge_state *old_bridge_state; 566 567 old_bridge_state = 568 drm_atomic_get_old_bridge_state(old_state, 569 iter); 570 if (WARN_ON(!old_bridge_state)) 571 return; 572 573 iter->funcs->atomic_disable(iter, old_bridge_state); 574 } else if (iter->funcs->disable) { 575 iter->funcs->disable(iter); 576 } 577 578 if (iter == bridge) 579 break; 580 } 581 } 582 EXPORT_SYMBOL(drm_atomic_bridge_chain_disable); 583 584 static void drm_atomic_bridge_call_post_disable(struct drm_bridge *bridge, 585 struct drm_atomic_state *old_state) 586 { 587 if (old_state && bridge->funcs->atomic_post_disable) { 588 struct drm_bridge_state *old_bridge_state; 589 590 old_bridge_state = 591 drm_atomic_get_old_bridge_state(old_state, 592 bridge); 593 if (WARN_ON(!old_bridge_state)) 594 return; 595 596 bridge->funcs->atomic_post_disable(bridge, 597 old_bridge_state); 598 } else if (bridge->funcs->post_disable) { 599 bridge->funcs->post_disable(bridge); 600 } 601 } 602 603 /** 604 * drm_atomic_bridge_chain_post_disable - cleans up after disabling all bridges 605 * in the encoder chain 606 * @bridge: bridge control structure 607 * @old_state: old atomic state 608 * 609 * Calls &drm_bridge_funcs.atomic_post_disable (falls back on 610 * &drm_bridge_funcs.post_disable) op for all the bridges in the encoder chain, 611 * starting from the first bridge to the last. These are called after completing 612 * &drm_encoder_helper_funcs.atomic_disable 613 * 614 * If a bridge sets @pre_enable_prev_first, then the @post_disable for that 615 * bridge will be called before the previous one to reverse the @pre_enable 616 * calling direction. 617 * 618 * Example: 619 * Bridge A ---> Bridge B ---> Bridge C ---> Bridge D ---> Bridge E 620 * 621 * With pre_enable_prev_first flag enable in Bridge B, D, E then the resulting 622 * @post_disable order would be, 623 * Bridge B, Bridge A, Bridge E, Bridge D, Bridge C. 624 * 625 * Note: the bridge passed should be the one closest to the encoder 626 */ 627 void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge, 628 struct drm_atomic_state *old_state) 629 { 630 struct drm_encoder *encoder; 631 struct drm_bridge *next, *limit; 632 633 if (!bridge) 634 return; 635 636 encoder = bridge->encoder; 637 638 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { 639 limit = NULL; 640 641 if (!list_is_last(&bridge->chain_node, &encoder->bridge_chain)) { 642 next = list_next_entry(bridge, chain_node); 643 644 if (next->pre_enable_prev_first) { 645 /* next bridge had requested that prev 646 * was enabled first, so disabled last 647 */ 648 limit = next; 649 650 /* Find the next bridge that has NOT requested 651 * prev to be enabled first / disabled last 652 */ 653 list_for_each_entry_from(next, &encoder->bridge_chain, 654 chain_node) { 655 if (!next->pre_enable_prev_first) { 656 next = list_prev_entry(next, chain_node); 657 limit = next; 658 break; 659 } 660 661 if (list_is_last(&next->chain_node, 662 &encoder->bridge_chain)) { 663 limit = next; 664 break; 665 } 666 } 667 668 /* Call these bridges in reverse order */ 669 list_for_each_entry_from_reverse(next, &encoder->bridge_chain, 670 chain_node) { 671 if (next == bridge) 672 break; 673 674 drm_atomic_bridge_call_post_disable(next, 675 old_state); 676 } 677 } 678 } 679 680 drm_atomic_bridge_call_post_disable(bridge, old_state); 681 682 if (limit) 683 /* Jump all bridges that we have already post_disabled */ 684 bridge = limit; 685 } 686 } 687 EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable); 688 689 static void drm_atomic_bridge_call_pre_enable(struct drm_bridge *bridge, 690 struct drm_atomic_state *old_state) 691 { 692 if (old_state && bridge->funcs->atomic_pre_enable) { 693 struct drm_bridge_state *old_bridge_state; 694 695 old_bridge_state = 696 drm_atomic_get_old_bridge_state(old_state, 697 bridge); 698 if (WARN_ON(!old_bridge_state)) 699 return; 700 701 bridge->funcs->atomic_pre_enable(bridge, old_bridge_state); 702 } else if (bridge->funcs->pre_enable) { 703 bridge->funcs->pre_enable(bridge); 704 } 705 } 706 707 /** 708 * drm_atomic_bridge_chain_pre_enable - prepares for enabling all bridges in 709 * the encoder chain 710 * @bridge: bridge control structure 711 * @old_state: old atomic state 712 * 713 * Calls &drm_bridge_funcs.atomic_pre_enable (falls back on 714 * &drm_bridge_funcs.pre_enable) op for all the bridges in the encoder chain, 715 * starting from the last bridge to the first. These are called before calling 716 * &drm_encoder_helper_funcs.atomic_enable 717 * 718 * If a bridge sets @pre_enable_prev_first, then the pre_enable for the 719 * prev bridge will be called before pre_enable of this bridge. 720 * 721 * Example: 722 * Bridge A ---> Bridge B ---> Bridge C ---> Bridge D ---> Bridge E 723 * 724 * With pre_enable_prev_first flag enable in Bridge B, D, E then the resulting 725 * @pre_enable order would be, 726 * Bridge C, Bridge D, Bridge E, Bridge A, Bridge B. 727 * 728 * Note: the bridge passed should be the one closest to the encoder 729 */ 730 void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge, 731 struct drm_atomic_state *old_state) 732 { 733 struct drm_encoder *encoder; 734 struct drm_bridge *iter, *next, *limit; 735 736 if (!bridge) 737 return; 738 739 encoder = bridge->encoder; 740 741 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { 742 if (iter->pre_enable_prev_first) { 743 next = iter; 744 limit = bridge; 745 list_for_each_entry_from_reverse(next, 746 &encoder->bridge_chain, 747 chain_node) { 748 if (next == bridge) 749 break; 750 751 if (!next->pre_enable_prev_first) { 752 /* Found first bridge that does NOT 753 * request prev to be enabled first 754 */ 755 limit = next; 756 break; 757 } 758 } 759 760 list_for_each_entry_from(next, &encoder->bridge_chain, chain_node) { 761 /* Call requested prev bridge pre_enable 762 * in order. 763 */ 764 if (next == iter) 765 /* At the first bridge to request prev 766 * bridges called first. 767 */ 768 break; 769 770 drm_atomic_bridge_call_pre_enable(next, old_state); 771 } 772 } 773 774 drm_atomic_bridge_call_pre_enable(iter, old_state); 775 776 if (iter->pre_enable_prev_first) 777 /* Jump all bridges that we have already pre_enabled */ 778 iter = limit; 779 780 if (iter == bridge) 781 break; 782 } 783 } 784 EXPORT_SYMBOL(drm_atomic_bridge_chain_pre_enable); 785 786 /** 787 * drm_atomic_bridge_chain_enable - enables all bridges in the encoder chain 788 * @bridge: bridge control structure 789 * @old_state: old atomic state 790 * 791 * Calls &drm_bridge_funcs.atomic_enable (falls back on 792 * &drm_bridge_funcs.enable) op for all the bridges in the encoder chain, 793 * starting from the first bridge to the last. These are called after completing 794 * &drm_encoder_helper_funcs.atomic_enable 795 * 796 * Note: the bridge passed should be the one closest to the encoder 797 */ 798 void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, 799 struct drm_atomic_state *old_state) 800 { 801 struct drm_encoder *encoder; 802 803 if (!bridge) 804 return; 805 806 encoder = bridge->encoder; 807 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { 808 if (bridge->funcs->atomic_enable) { 809 struct drm_bridge_state *old_bridge_state; 810 811 old_bridge_state = 812 drm_atomic_get_old_bridge_state(old_state, 813 bridge); 814 if (WARN_ON(!old_bridge_state)) 815 return; 816 817 bridge->funcs->atomic_enable(bridge, old_bridge_state); 818 } else if (bridge->funcs->enable) { 819 bridge->funcs->enable(bridge); 820 } 821 } 822 } 823 EXPORT_SYMBOL(drm_atomic_bridge_chain_enable); 824 825 static int drm_atomic_bridge_check(struct drm_bridge *bridge, 826 struct drm_crtc_state *crtc_state, 827 struct drm_connector_state *conn_state) 828 { 829 if (bridge->funcs->atomic_check) { 830 struct drm_bridge_state *bridge_state; 831 int ret; 832 833 bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, 834 bridge); 835 if (WARN_ON(!bridge_state)) 836 return -EINVAL; 837 838 ret = bridge->funcs->atomic_check(bridge, bridge_state, 839 crtc_state, conn_state); 840 if (ret) 841 return ret; 842 } else if (bridge->funcs->mode_fixup) { 843 if (!bridge->funcs->mode_fixup(bridge, &crtc_state->mode, 844 &crtc_state->adjusted_mode)) 845 return -EINVAL; 846 } 847 848 return 0; 849 } 850 851 static int select_bus_fmt_recursive(struct drm_bridge *first_bridge, 852 struct drm_bridge *cur_bridge, 853 struct drm_crtc_state *crtc_state, 854 struct drm_connector_state *conn_state, 855 u32 out_bus_fmt) 856 { 857 unsigned int i, num_in_bus_fmts = 0; 858 struct drm_bridge_state *cur_state; 859 struct drm_bridge *prev_bridge; 860 u32 *in_bus_fmts; 861 int ret; 862 863 prev_bridge = drm_bridge_get_prev_bridge(cur_bridge); 864 cur_state = drm_atomic_get_new_bridge_state(crtc_state->state, 865 cur_bridge); 866 867 /* 868 * If bus format negotiation is not supported by this bridge, let's 869 * pass MEDIA_BUS_FMT_FIXED to the previous bridge in the chain and 870 * hope that it can handle this situation gracefully (by providing 871 * appropriate default values). 872 */ 873 if (!cur_bridge->funcs->atomic_get_input_bus_fmts) { 874 if (cur_bridge != first_bridge) { 875 ret = select_bus_fmt_recursive(first_bridge, 876 prev_bridge, crtc_state, 877 conn_state, 878 MEDIA_BUS_FMT_FIXED); 879 if (ret) 880 return ret; 881 } 882 883 /* 884 * Driver does not implement the atomic state hooks, but that's 885 * fine, as long as it does not access the bridge state. 886 */ 887 if (cur_state) { 888 cur_state->input_bus_cfg.format = MEDIA_BUS_FMT_FIXED; 889 cur_state->output_bus_cfg.format = out_bus_fmt; 890 } 891 892 return 0; 893 } 894 895 /* 896 * If the driver implements ->atomic_get_input_bus_fmts() it 897 * should also implement the atomic state hooks. 898 */ 899 if (WARN_ON(!cur_state)) 900 return -EINVAL; 901 902 in_bus_fmts = cur_bridge->funcs->atomic_get_input_bus_fmts(cur_bridge, 903 cur_state, 904 crtc_state, 905 conn_state, 906 out_bus_fmt, 907 &num_in_bus_fmts); 908 if (!num_in_bus_fmts) 909 return -ENOTSUPP; 910 else if (!in_bus_fmts) 911 return -ENOMEM; 912 913 if (first_bridge == cur_bridge) { 914 cur_state->input_bus_cfg.format = in_bus_fmts[0]; 915 cur_state->output_bus_cfg.format = out_bus_fmt; 916 kfree(in_bus_fmts); 917 return 0; 918 } 919 920 for (i = 0; i < num_in_bus_fmts; i++) { 921 ret = select_bus_fmt_recursive(first_bridge, prev_bridge, 922 crtc_state, conn_state, 923 in_bus_fmts[i]); 924 if (ret != -ENOTSUPP) 925 break; 926 } 927 928 if (!ret) { 929 cur_state->input_bus_cfg.format = in_bus_fmts[i]; 930 cur_state->output_bus_cfg.format = out_bus_fmt; 931 } 932 933 kfree(in_bus_fmts); 934 return ret; 935 } 936 937 /* 938 * This function is called by &drm_atomic_bridge_chain_check() just before 939 * calling &drm_bridge_funcs.atomic_check() on all elements of the chain. 940 * It performs bus format negotiation between bridge elements. The negotiation 941 * happens in reverse order, starting from the last element in the chain up to 942 * @bridge. 943 * 944 * Negotiation starts by retrieving supported output bus formats on the last 945 * bridge element and testing them one by one. The test is recursive, meaning 946 * that for each tested output format, the whole chain will be walked backward, 947 * and each element will have to choose an input bus format that can be 948 * transcoded to the requested output format. When a bridge element does not 949 * support transcoding into a specific output format -ENOTSUPP is returned and 950 * the next bridge element will have to try a different format. If none of the 951 * combinations worked, -ENOTSUPP is returned and the atomic modeset will fail. 952 * 953 * This implementation is relying on 954 * &drm_bridge_funcs.atomic_get_output_bus_fmts() and 955 * &drm_bridge_funcs.atomic_get_input_bus_fmts() to gather supported 956 * input/output formats. 957 * 958 * When &drm_bridge_funcs.atomic_get_output_bus_fmts() is not implemented by 959 * the last element of the chain, &drm_atomic_bridge_chain_select_bus_fmts() 960 * tries a single format: &drm_connector.display_info.bus_formats[0] if 961 * available, MEDIA_BUS_FMT_FIXED otherwise. 962 * 963 * When &drm_bridge_funcs.atomic_get_input_bus_fmts() is not implemented, 964 * &drm_atomic_bridge_chain_select_bus_fmts() skips the negotiation on the 965 * bridge element that lacks this hook and asks the previous element in the 966 * chain to try MEDIA_BUS_FMT_FIXED. It's up to bridge drivers to decide what 967 * to do in that case (fail if they want to enforce bus format negotiation, or 968 * provide a reasonable default if they need to support pipelines where not 969 * all elements support bus format negotiation). 970 */ 971 static int 972 drm_atomic_bridge_chain_select_bus_fmts(struct drm_bridge *bridge, 973 struct drm_crtc_state *crtc_state, 974 struct drm_connector_state *conn_state) 975 { 976 struct drm_connector *conn = conn_state->connector; 977 struct drm_encoder *encoder = bridge->encoder; 978 struct drm_bridge_state *last_bridge_state; 979 unsigned int i, num_out_bus_fmts = 0; 980 struct drm_bridge *last_bridge; 981 u32 *out_bus_fmts; 982 int ret = 0; 983 984 last_bridge = list_last_entry(&encoder->bridge_chain, 985 struct drm_bridge, chain_node); 986 last_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, 987 last_bridge); 988 989 if (last_bridge->funcs->atomic_get_output_bus_fmts) { 990 const struct drm_bridge_funcs *funcs = last_bridge->funcs; 991 992 /* 993 * If the driver implements ->atomic_get_output_bus_fmts() it 994 * should also implement the atomic state hooks. 995 */ 996 if (WARN_ON(!last_bridge_state)) 997 return -EINVAL; 998 999 out_bus_fmts = funcs->atomic_get_output_bus_fmts(last_bridge, 1000 last_bridge_state, 1001 crtc_state, 1002 conn_state, 1003 &num_out_bus_fmts); 1004 if (!num_out_bus_fmts) 1005 return -ENOTSUPP; 1006 else if (!out_bus_fmts) 1007 return -ENOMEM; 1008 } else { 1009 num_out_bus_fmts = 1; 1010 out_bus_fmts = kmalloc(sizeof(*out_bus_fmts), GFP_KERNEL); 1011 if (!out_bus_fmts) 1012 return -ENOMEM; 1013 1014 if (conn->display_info.num_bus_formats && 1015 conn->display_info.bus_formats) 1016 out_bus_fmts[0] = conn->display_info.bus_formats[0]; 1017 else 1018 out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED; 1019 } 1020 1021 for (i = 0; i < num_out_bus_fmts; i++) { 1022 ret = select_bus_fmt_recursive(bridge, last_bridge, crtc_state, 1023 conn_state, out_bus_fmts[i]); 1024 if (ret != -ENOTSUPP) 1025 break; 1026 } 1027 1028 kfree(out_bus_fmts); 1029 1030 return ret; 1031 } 1032 1033 static void 1034 drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge, 1035 struct drm_connector *conn, 1036 struct drm_atomic_state *state) 1037 { 1038 struct drm_bridge_state *bridge_state, *next_bridge_state; 1039 struct drm_bridge *next_bridge; 1040 u32 output_flags = 0; 1041 1042 bridge_state = drm_atomic_get_new_bridge_state(state, bridge); 1043 1044 /* No bridge state attached to this bridge => nothing to propagate. */ 1045 if (!bridge_state) 1046 return; 1047 1048 next_bridge = drm_bridge_get_next_bridge(bridge); 1049 1050 /* 1051 * Let's try to apply the most common case here, that is, propagate 1052 * display_info flags for the last bridge, and propagate the input 1053 * flags of the next bridge element to the output end of the current 1054 * bridge when the bridge is not the last one. 1055 * There are exceptions to this rule, like when signal inversion is 1056 * happening at the board level, but that's something drivers can deal 1057 * with from their &drm_bridge_funcs.atomic_check() implementation by 1058 * simply overriding the flags value we've set here. 1059 */ 1060 if (!next_bridge) { 1061 output_flags = conn->display_info.bus_flags; 1062 } else { 1063 next_bridge_state = drm_atomic_get_new_bridge_state(state, 1064 next_bridge); 1065 /* 1066 * No bridge state attached to the next bridge, just leave the 1067 * flags to 0. 1068 */ 1069 if (next_bridge_state) 1070 output_flags = next_bridge_state->input_bus_cfg.flags; 1071 } 1072 1073 bridge_state->output_bus_cfg.flags = output_flags; 1074 1075 /* 1076 * Propagate the output flags to the input end of the bridge. Again, it's 1077 * not necessarily what all bridges want, but that's what most of them 1078 * do, and by doing that by default we avoid forcing drivers to 1079 * duplicate the "dummy propagation" logic. 1080 */ 1081 bridge_state->input_bus_cfg.flags = output_flags; 1082 } 1083 1084 /** 1085 * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain 1086 * @bridge: bridge control structure 1087 * @crtc_state: new CRTC state 1088 * @conn_state: new connector state 1089 * 1090 * First trigger a bus format negotiation before calling 1091 * &drm_bridge_funcs.atomic_check() (falls back on 1092 * &drm_bridge_funcs.mode_fixup()) op for all the bridges in the encoder chain, 1093 * starting from the last bridge to the first. These are called before calling 1094 * &drm_encoder_helper_funcs.atomic_check() 1095 * 1096 * RETURNS: 1097 * 0 on success, a negative error code on failure 1098 */ 1099 int drm_atomic_bridge_chain_check(struct drm_bridge *bridge, 1100 struct drm_crtc_state *crtc_state, 1101 struct drm_connector_state *conn_state) 1102 { 1103 struct drm_connector *conn = conn_state->connector; 1104 struct drm_encoder *encoder; 1105 struct drm_bridge *iter; 1106 int ret; 1107 1108 if (!bridge) 1109 return 0; 1110 1111 ret = drm_atomic_bridge_chain_select_bus_fmts(bridge, crtc_state, 1112 conn_state); 1113 if (ret) 1114 return ret; 1115 1116 encoder = bridge->encoder; 1117 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { 1118 int ret; 1119 1120 /* 1121 * Bus flags are propagated by default. If a bridge needs to 1122 * tweak the input bus flags for any reason, it should happen 1123 * in its &drm_bridge_funcs.atomic_check() implementation such 1124 * that preceding bridges in the chain can propagate the new 1125 * bus flags. 1126 */ 1127 drm_atomic_bridge_propagate_bus_flags(iter, conn, 1128 crtc_state->state); 1129 1130 ret = drm_atomic_bridge_check(iter, crtc_state, conn_state); 1131 if (ret) 1132 return ret; 1133 1134 if (iter == bridge) 1135 break; 1136 } 1137 1138 return 0; 1139 } 1140 EXPORT_SYMBOL(drm_atomic_bridge_chain_check); 1141 1142 /** 1143 * drm_bridge_detect - check if anything is attached to the bridge output 1144 * @bridge: bridge control structure 1145 * 1146 * If the bridge supports output detection, as reported by the 1147 * DRM_BRIDGE_OP_DETECT bridge ops flag, call &drm_bridge_funcs.detect for the 1148 * bridge and return the connection status. Otherwise return 1149 * connector_status_unknown. 1150 * 1151 * RETURNS: 1152 * The detection status on success, or connector_status_unknown if the bridge 1153 * doesn't support output detection. 1154 */ 1155 enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge) 1156 { 1157 if (!(bridge->ops & DRM_BRIDGE_OP_DETECT)) 1158 return connector_status_unknown; 1159 1160 return bridge->funcs->detect(bridge); 1161 } 1162 EXPORT_SYMBOL_GPL(drm_bridge_detect); 1163 1164 /** 1165 * drm_bridge_get_modes - fill all modes currently valid for the sink into the 1166 * @connector 1167 * @bridge: bridge control structure 1168 * @connector: the connector to fill with modes 1169 * 1170 * If the bridge supports output modes retrieval, as reported by the 1171 * DRM_BRIDGE_OP_MODES bridge ops flag, call &drm_bridge_funcs.get_modes to 1172 * fill the connector with all valid modes and return the number of modes 1173 * added. Otherwise return 0. 1174 * 1175 * RETURNS: 1176 * The number of modes added to the connector. 1177 */ 1178 int drm_bridge_get_modes(struct drm_bridge *bridge, 1179 struct drm_connector *connector) 1180 { 1181 if (!(bridge->ops & DRM_BRIDGE_OP_MODES)) 1182 return 0; 1183 1184 return bridge->funcs->get_modes(bridge, connector); 1185 } 1186 EXPORT_SYMBOL_GPL(drm_bridge_get_modes); 1187 1188 /** 1189 * drm_bridge_edid_read - read the EDID data of the connected display 1190 * @bridge: bridge control structure 1191 * @connector: the connector to read EDID for 1192 * 1193 * If the bridge supports output EDID retrieval, as reported by the 1194 * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.edid_read to get 1195 * the EDID and return it. Otherwise return NULL. 1196 * 1197 * RETURNS: 1198 * The retrieved EDID on success, or NULL otherwise. 1199 */ 1200 const struct drm_edid *drm_bridge_edid_read(struct drm_bridge *bridge, 1201 struct drm_connector *connector) 1202 { 1203 if (!(bridge->ops & DRM_BRIDGE_OP_EDID)) 1204 return NULL; 1205 1206 return bridge->funcs->edid_read(bridge, connector); 1207 } 1208 EXPORT_SYMBOL_GPL(drm_bridge_edid_read); 1209 1210 /** 1211 * drm_bridge_hpd_enable - enable hot plug detection for the bridge 1212 * @bridge: bridge control structure 1213 * @cb: hot-plug detection callback 1214 * @data: data to be passed to the hot-plug detection callback 1215 * 1216 * Call &drm_bridge_funcs.hpd_enable if implemented and register the given @cb 1217 * and @data as hot plug notification callback. From now on the @cb will be 1218 * called with @data when an output status change is detected by the bridge, 1219 * until hot plug notification gets disabled with drm_bridge_hpd_disable(). 1220 * 1221 * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in 1222 * bridge->ops. This function shall not be called when the flag is not set. 1223 * 1224 * Only one hot plug detection callback can be registered at a time, it is an 1225 * error to call this function when hot plug detection is already enabled for 1226 * the bridge. 1227 */ 1228 void drm_bridge_hpd_enable(struct drm_bridge *bridge, 1229 void (*cb)(void *data, 1230 enum drm_connector_status status), 1231 void *data) 1232 { 1233 if (!(bridge->ops & DRM_BRIDGE_OP_HPD)) 1234 return; 1235 1236 mutex_lock(&bridge->hpd_mutex); 1237 1238 if (WARN(bridge->hpd_cb, "Hot plug detection already enabled\n")) 1239 goto unlock; 1240 1241 bridge->hpd_cb = cb; 1242 bridge->hpd_data = data; 1243 1244 if (bridge->funcs->hpd_enable) 1245 bridge->funcs->hpd_enable(bridge); 1246 1247 unlock: 1248 mutex_unlock(&bridge->hpd_mutex); 1249 } 1250 EXPORT_SYMBOL_GPL(drm_bridge_hpd_enable); 1251 1252 /** 1253 * drm_bridge_hpd_disable - disable hot plug detection for the bridge 1254 * @bridge: bridge control structure 1255 * 1256 * Call &drm_bridge_funcs.hpd_disable if implemented and unregister the hot 1257 * plug detection callback previously registered with drm_bridge_hpd_enable(). 1258 * Once this function returns the callback will not be called by the bridge 1259 * when an output status change occurs. 1260 * 1261 * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in 1262 * bridge->ops. This function shall not be called when the flag is not set. 1263 */ 1264 void drm_bridge_hpd_disable(struct drm_bridge *bridge) 1265 { 1266 if (!(bridge->ops & DRM_BRIDGE_OP_HPD)) 1267 return; 1268 1269 mutex_lock(&bridge->hpd_mutex); 1270 if (bridge->funcs->hpd_disable) 1271 bridge->funcs->hpd_disable(bridge); 1272 1273 bridge->hpd_cb = NULL; 1274 bridge->hpd_data = NULL; 1275 mutex_unlock(&bridge->hpd_mutex); 1276 } 1277 EXPORT_SYMBOL_GPL(drm_bridge_hpd_disable); 1278 1279 /** 1280 * drm_bridge_hpd_notify - notify hot plug detection events 1281 * @bridge: bridge control structure 1282 * @status: output connection status 1283 * 1284 * Bridge drivers shall call this function to report hot plug events when they 1285 * detect a change in the output status, when hot plug detection has been 1286 * enabled by drm_bridge_hpd_enable(). 1287 * 1288 * This function shall be called in a context that can sleep. 1289 */ 1290 void drm_bridge_hpd_notify(struct drm_bridge *bridge, 1291 enum drm_connector_status status) 1292 { 1293 mutex_lock(&bridge->hpd_mutex); 1294 if (bridge->hpd_cb) 1295 bridge->hpd_cb(bridge->hpd_data, status); 1296 mutex_unlock(&bridge->hpd_mutex); 1297 } 1298 EXPORT_SYMBOL_GPL(drm_bridge_hpd_notify); 1299 1300 #ifdef CONFIG_OF 1301 /** 1302 * of_drm_find_bridge - find the bridge corresponding to the device node in 1303 * the global bridge list 1304 * 1305 * @np: device node 1306 * 1307 * RETURNS: 1308 * drm_bridge control struct on success, NULL on failure 1309 */ 1310 struct drm_bridge *of_drm_find_bridge(struct device_node *np) 1311 { 1312 struct drm_bridge *bridge; 1313 1314 mutex_lock(&bridge_lock); 1315 1316 list_for_each_entry(bridge, &bridge_list, list) { 1317 if (bridge->of_node == np) { 1318 mutex_unlock(&bridge_lock); 1319 return bridge; 1320 } 1321 } 1322 1323 mutex_unlock(&bridge_lock); 1324 return NULL; 1325 } 1326 EXPORT_SYMBOL(of_drm_find_bridge); 1327 #endif 1328 1329 MODULE_AUTHOR("Ajay Kumar <ajaykumar.rs@samsung.com>"); 1330 MODULE_DESCRIPTION("DRM bridge infrastructure"); 1331 MODULE_LICENSE("GPL and additional rights"); 1332